From bfbefb7b899ec4a28db853063e9d34fbe42fc6c0 Mon Sep 17 00:00:00 2001 From: Sylvestre Ledru Date: Thu, 26 Nov 2020 15:40:03 +0100 Subject: New upstream version 8.15 --- .clang-format | 5 + .gitignore | 4 + .travis.yml | 81 +- CMakeLists.txt | 114 +- CONTRIBUTING.md | 4 +- README.md | 24 +- boost-1.64-all-private.imp | 31 +- boost-1.64-all.imp | 2 +- boost-all.imp | 2 +- docs/IWYUStyle.md | 286 ++ fix_includes.py | 34 +- fix_includes_test.py | 63 + gcc.libc.imp | 1 + gcc.symbols.imp | 4 + generate_qt_mappings.py | 170 + include-what-you-use.1 | 282 ++ iwyu-check-license-header.py | 277 ++ iwyu.cc | 455 ++- iwyu_ast_util.cc | 181 +- iwyu_ast_util.h | 73 +- iwyu_cache.h | 2 +- iwyu_driver.cc | 7 +- iwyu_getopt.cc | 4 +- iwyu_globals.cc | 8 +- iwyu_globals.h | 2 +- iwyu_include_picker.cc | 276 +- iwyu_include_picker.h | 85 +- iwyu_lexer_utils.cc | 4 +- iwyu_location_util.h | 2 +- iwyu_output.cc | 154 +- iwyu_output.h | 7 +- iwyu_path_util.cc | 8 +- iwyu_port.h | 88 + iwyu_preprocessor.cc | 74 +- iwyu_preprocessor.h | 4 +- iwyu_string_util.h | 2 +- iwyu_test_util.py | 4 +- iwyu_tool.py | 63 +- iwyu_tool_test.py | 54 +- iwyu_version.h | 2 +- more_tests/iwyu_include_picker_test.cc | 13 +- port.h | 90 - qt5_11.imp | 3853 ++++++++++++++++++++ qt5_4.imp | 1714 ++++----- run_iwyu_tests.py | 18 +- scrub-logs.py | 4 +- tests/c/elaborated_struct.c | 6 + tests/cxx/alias_template.cc | 25 +- tests/cxx/alias_template_use-d1.h | 10 + tests/cxx/alias_template_use-i1.h | 14 + tests/cxx/alias_template_use-i2.h | 11 + tests/cxx/alias_template_use.cc | 35 + tests/cxx/associated_skipped-d1.h | 10 + tests/cxx/associated_skipped-i1.h | 17 + tests/cxx/associated_skipped.cc | 59 + tests/cxx/associated_skipped.h | 23 + tests/cxx/badinc.cc | 61 +- tests/cxx/binary_type_trait-d1.h | 15 + tests/cxx/binary_type_trait-i1.h | 15 + tests/cxx/binary_type_trait-i2.h | 17 + tests/cxx/binary_type_trait.cc | 48 + tests/cxx/builtins_new_included.cc | 31 - tests/cxx/builtins_template.cc | 2 + tests/cxx/dotdot.cc | 29 + tests/cxx/elaborated_type_union.h | 2 +- tests/cxx/enum_base-d1.h | 15 + tests/cxx/enum_base-i1.h | 15 + tests/cxx/enum_base.cc | 29 + tests/cxx/explicit_instantiation-template.h | 2 +- tests/cxx/explicit_instantiation-template_direct.h | 2 +- tests/cxx/explicit_instantiation.cc | 2 +- .../cxx/explicit_instantiation2-template_helpers.h | 2 +- tests/cxx/explicit_instantiation2-template_short.h | 4 +- ...explicit_instantiation2-template_short_direct.h | 3 +- tests/cxx/explicit_instantiation2.cc | 2 +- tests/cxx/export_near.h | 20 + tests/cxx/export_private_near.h | 20 + tests/cxx/fwd_decl_final-d1.h | 19 + tests/cxx/fwd_decl_final.cc | 31 + tests/cxx/fwd_decl_final.h | 36 + .../cxx/fwd_decl_of_nested_class_defined_later.cc | 2 +- tests/cxx/header_in_subdir.cc | 30 + tests/cxx/header_in_subdir_nopath.cc | 30 + tests/cxx/header_in_subfolder.cc | 30 - tests/cxx/header_in_subfolder_nopath.cc | 30 - tests/cxx/header_near.cc | 2 +- tests/cxx/header_near.h | 2 +- tests/cxx/inline_namespace-d1.h | 15 + tests/cxx/inline_namespace-i1.h | 24 + tests/cxx/inline_namespace.cc | 26 + tests/cxx/inline_namespace.h | 35 + tests/cxx/keep_moc-d1.h | 10 + tests/cxx/keep_moc-i1.h | 33 + tests/cxx/keep_moc.cc | 37 + tests/cxx/keep_moc.moc | 13 + tests/cxx/macro_location-byteswap.h | 9 + tests/cxx/no_fwd_decls.cc | 4 + tests/cxx/operator_new.cc | 86 + tests/cxx/pch_in_code.cc | 2 +- tests/cxx/placement_new-d1.h | 15 + tests/cxx/placement_new-i1.h | 24 + tests/cxx/placement_new.cc | 151 + tests/cxx/precomputed_tpl_args.cc | 5 +- tests/cxx/private.h | 22 + tests/cxx/quoted_includes_first.cc | 8 +- tests/cxx/quoted_includes_first.h | 10 +- tests/cxx/relative_exported_mapped_include-d1.h | 15 + tests/cxx/relative_exported_mapped_include.cc | 22 + tests/cxx/relative_exported_mapped_include.imp | 3 + tests/cxx/relative_include_of_double_export-d1.h | 15 + tests/cxx/relative_include_of_double_export.cc | 23 + tests/cxx/relative_include_of_export.cc | 21 + tests/cxx/relative_include_of_export_added-d1.h | 15 + tests/cxx/relative_include_of_export_added.cc | 29 + tests/cxx/sizeof_in_template_arg.cc | 41 + tests/cxx/specialization_needs_decl-d1.h | 2 + tests/cxx/specialization_needs_decl-i1.h | 18 + tests/cxx/specialization_needs_decl.cc | 11 + tests/cxx/subdir/direct_subdir.h | 17 + tests/cxx/subdir/dotdot_indirect.h | 18 + tests/cxx/subdir/indirect_subdir.h | 16 + .../subdir/relative_exported_mapped_include-i1.h | 15 + tests/cxx/subfolder/direct_subfolder.h | 17 - tests/cxx/subfolder/indirect_subfolder.h | 16 - tests/cxx/template_default_args_roundtrip-direct.h | 2 +- .../cxx/template_default_args_roundtrip-indirect.h | 2 +- .../cxx/template_default_args_roundtrip-template.h | 2 +- tests/cxx/template_specialization.cc | 13 + tests/cxx/typedef_in_template.cc | 68 +- 129 files changed, 8504 insertions(+), 1819 deletions(-) create mode 100644 docs/IWYUStyle.md create mode 100755 generate_qt_mappings.py create mode 100644 include-what-you-use.1 create mode 100755 iwyu-check-license-header.py create mode 100644 iwyu_port.h delete mode 100644 port.h create mode 100644 qt5_11.imp create mode 100644 tests/cxx/alias_template_use-d1.h create mode 100644 tests/cxx/alias_template_use-i1.h create mode 100644 tests/cxx/alias_template_use-i2.h create mode 100644 tests/cxx/alias_template_use.cc create mode 100644 tests/cxx/associated_skipped-d1.h create mode 100644 tests/cxx/associated_skipped-i1.h create mode 100644 tests/cxx/associated_skipped.cc create mode 100644 tests/cxx/associated_skipped.h create mode 100644 tests/cxx/binary_type_trait-d1.h create mode 100644 tests/cxx/binary_type_trait-i1.h create mode 100644 tests/cxx/binary_type_trait-i2.h create mode 100644 tests/cxx/binary_type_trait.cc delete mode 100644 tests/cxx/builtins_new_included.cc create mode 100644 tests/cxx/dotdot.cc create mode 100644 tests/cxx/enum_base-d1.h create mode 100644 tests/cxx/enum_base-i1.h create mode 100644 tests/cxx/enum_base.cc create mode 100644 tests/cxx/export_near.h create mode 100644 tests/cxx/export_private_near.h create mode 100644 tests/cxx/fwd_decl_final-d1.h create mode 100644 tests/cxx/fwd_decl_final.cc create mode 100644 tests/cxx/fwd_decl_final.h create mode 100644 tests/cxx/header_in_subdir.cc create mode 100644 tests/cxx/header_in_subdir_nopath.cc delete mode 100644 tests/cxx/header_in_subfolder.cc delete mode 100644 tests/cxx/header_in_subfolder_nopath.cc create mode 100644 tests/cxx/inline_namespace-d1.h create mode 100644 tests/cxx/inline_namespace-i1.h create mode 100644 tests/cxx/inline_namespace.cc create mode 100644 tests/cxx/inline_namespace.h create mode 100644 tests/cxx/keep_moc-d1.h create mode 100644 tests/cxx/keep_moc-i1.h create mode 100644 tests/cxx/keep_moc.cc create mode 100644 tests/cxx/keep_moc.moc create mode 100644 tests/cxx/operator_new.cc create mode 100644 tests/cxx/placement_new-d1.h create mode 100644 tests/cxx/placement_new-i1.h create mode 100644 tests/cxx/placement_new.cc create mode 100644 tests/cxx/private.h create mode 100644 tests/cxx/relative_exported_mapped_include-d1.h create mode 100644 tests/cxx/relative_exported_mapped_include.cc create mode 100644 tests/cxx/relative_exported_mapped_include.imp create mode 100644 tests/cxx/relative_include_of_double_export-d1.h create mode 100644 tests/cxx/relative_include_of_double_export.cc create mode 100644 tests/cxx/relative_include_of_export.cc create mode 100644 tests/cxx/relative_include_of_export_added-d1.h create mode 100644 tests/cxx/relative_include_of_export_added.cc create mode 100644 tests/cxx/sizeof_in_template_arg.cc create mode 100644 tests/cxx/specialization_needs_decl-i1.h create mode 100644 tests/cxx/subdir/direct_subdir.h create mode 100644 tests/cxx/subdir/dotdot_indirect.h create mode 100644 tests/cxx/subdir/indirect_subdir.h create mode 100644 tests/cxx/subdir/relative_exported_mapped_include-i1.h delete mode 100644 tests/cxx/subfolder/direct_subfolder.h delete mode 100644 tests/cxx/subfolder/indirect_subfolder.h diff --git a/.clang-format b/.clang-format index 23aa6f5..afd9018 100644 --- a/.clang-format +++ b/.clang-format @@ -1,3 +1,8 @@ BasedOnStyle: Google AllowShortBlocksOnASingleLine: false AllowShortIfStatementsOnASingleLine: false +AllowShortFunctionsOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortLoopsOnASingleLine: false +SortIncludes: false +SortUsingDeclarations: false diff --git a/.gitignore b/.gitignore index 9948916..297e5e2 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,7 @@ __pycache__ .gdb_history compile_commands.json +tags +TAGS + +/build diff --git a/.travis.yml b/.travis.yml index b265cb0..9f6270d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,41 +1,40 @@ - -language: cpp - -addons: - apt: - sources: - - ubuntu-toolchain-r-test - - llvm-toolchain-trusty - packages: - - ninja-build - # TODO: These should really be the snapshots packages, but they are currently - # broken. Remove the '-9' once they get fixed (see issue #642 for more info) - - llvm-9-dev - - llvm-9-tools - - libclang-9-dev - - clang-9 - -before_install: - # Install a supported cmake version (>= 3.4.3) - - wget -O cmake.sh https://cmake.org/files/v3.10/cmake-3.10.0-rc1-Linux-x86_64.sh - - sudo sh cmake.sh --skip-license --exclude-subdir --prefix=/usr/local - - # Extract the version number from the most-recently installed LLVM - - VERSION=`ls -t /usr/lib/ | grep '^llvm-' | head -n 1 | sed -E 's/llvm-(.+)/\1/'` - - # Absolute paths to LLVM's root and bin directory - - ROOT_PATH=`llvm-config-$VERSION --prefix` - - BIN_PATH=`llvm-config-$VERSION --bindir` - -script: -# Build IWYU - - mkdir build - - cd build - - cmake -GNinja -DLLVM_TEMPORARILY_ALLOW_OLD_TOOLCHAIN=yes -DCMAKE_PREFIX_PATH=$ROOT_PATH -DCMAKE_C_COMPILER=$BIN_PATH/clang -DCMAKE_CXX_COMPILER=$BIN_PATH/clang++ -DCMAKE_INSTALL_PREFIX=./ ../ - - ninja install - -# Test IWYU - - cd .. - - python run_iwyu_tests.py -- build/bin/include-what-you-use - - python fix_includes_test.py - - python iwyu_tool_test.py + +dist: bionic +language: cpp + +addons: + apt: + sources: + - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-11 main' + key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key' + packages: + - cmake + - ninja-build + - llvm-11-dev + - libclang-11-dev + - clang-11 + +before_install: + # Extract the version number from the most-recently installed LLVM + - VERSION=`ls -t /usr/lib/ | grep '^llvm-' | head -n 1 | sed -E 's/llvm-(.+)/\1/'` + + # Absolute paths to LLVM's root and bin directory + - PREFIX_PATH=`llvm-config-$VERSION --prefix` + - BIN_PATH=`llvm-config-$VERSION --bindir` + +script: +# Build IWYU + - mkdir build + - cd build + - cmake -GNinja -DCMAKE_PREFIX_PATH=$PREFIX_PATH -DCMAKE_C_COMPILER=$BIN_PATH/clang -DCMAKE_CXX_COMPILER=$BIN_PATH/clang++ -DCMAKE_INSTALL_PREFIX=./ ../ + - ninja + +# Test IWYU + - CTEST_OUTPUT_ON_FAILURE=1 ninja test + +# Test install + - ninja install + +# Check license headers + - cd ../ + - git ls-tree --full-tree --name-only -r HEAD | xargs ./iwyu-check-license-header.py diff --git a/CMakeLists.txt b/CMakeLists.txt index b795f24..60477ba 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -10,6 +10,10 @@ endif() if (NOT IWYU_IN_TREE) cmake_policy(SET CMP0048 NEW) + if (POLICY CMP0077) + cmake_policy(SET CMP0077 NEW) + endif() + project(include-what-you-use) find_package(LLVM CONFIG REQUIRED) @@ -22,6 +26,10 @@ endif() message(STATUS "IWYU: configuring for LLVM ${LLVM_VERSION}...") +# The good default is given by the llvm toolchain installation itself, but still in +# case both static and shared libraries are available, allow to override that default. +option(IWYU_LINK_CLANG_DYLIB "Link against the clang dynamic library" ${CLANG_LINK_CLANG_DYLIB}) + set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) add_definitions(${LLVM_DEFINITIONS}) @@ -54,13 +62,37 @@ add_llvm_executable(include-what-you-use iwyu_verrs.cc ) -if (IWYU_IN_TREE) - # Add a dependency on clang-headers to ensure the builtin headers are - # available when IWYU is executed from the build dir. - # The clang-headers target is only available in in-tree builds. - add_dependencies(include-what-you-use clang-headers) +# Synthesize a clang-resource-headers target for out-of-tree builds (in-tree +# already has it available by default) +if (NOT IWYU_IN_TREE) + # Use only major.minor.patch for the resource directory structure; some + # platforms include suffix in LLVM_VERSION. + set(llvm_ver ${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}) + set(clang_headers_src "${LLVM_LIBRARY_DIR}/clang/${llvm_ver}/include") + set(clang_headers_dst "${CMAKE_BINARY_DIR}/lib/clang/${llvm_ver}/include") + + file(GLOB_RECURSE in_files RELATIVE "${clang_headers_src}" + "${clang_headers_src}/*") + + set(out_files) + foreach (file ${in_files}) + set(src "${clang_headers_src}/${file}") + set(dst "${clang_headers_dst}/${file}") + + add_custom_command(OUTPUT "${dst}" + DEPENDS "${src}" + COMMAND ${CMAKE_COMMAND} -E copy_if_different "${src}" "${dst}" + COMMENT "Copying clang's ${file}...") + list(APPEND out_files "${dst}") + endforeach() + + add_custom_target(clang-resource-headers ALL DEPENDS ${out_files}) endif() +# Add a dependency on clang-resource-headers to ensure the builtin headers are +# available when IWYU is executed from the build dir. +add_dependencies(include-what-you-use clang-resource-headers) + if (MINGW) # Work around 'too many sections' error with MINGW/GCC set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wa,-mbig-obj") @@ -75,33 +107,33 @@ if (MSVC) # Enable bigobj support and sane C++ exception semantics. set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /EHsc") +endif() - # Put project in solution folder - set_target_properties(include-what-you-use - PROPERTIES FOLDER "Clang executables" +# If only clang-cpp is available, we take that. +if (IWYU_LINK_CLANG_DYLIB) + target_link_libraries(include-what-you-use PRIVATE clang-cpp) +else() + target_link_libraries(include-what-you-use + PRIVATE + clangBasic + clangLex + clangAST + clangSema + clangFrontend + clangDriver + + # Revision [1] in clang moved PCHContainerOperations from Frontend + # to Serialization, but this broke builds that set + # -DBUILD_SHARED_LIBS=on. Revision [2] is a followup that works + # around the issue by adding an explicit dependency on Serialization + # wherever there was a dependency on Frontend. Since we depend on + # Frontend, we need an explicit dependency on Serialization too. + # [1] https://llvm.org/viewvc/llvm-project?view=revision&revision=348907 + # [2] https://llvm.org/viewvc/llvm-project?view=revision&revision=348915 + clangSerialization ) endif() -target_link_libraries(include-what-you-use - PRIVATE - clangBasic - clangLex - clangAST - clangSema - clangFrontend - clangDriver - - # Revision [1] in clang moved PCHContainerOperations from Frontend - # to Serialization, but this broke builds that set - # -DBUILD_SHARED_LIBS=on. Revision [2] is a followup that works - # around the issue by adding an explicit dependency on Serialization - # wherever there was a dependency on Frontend. Since we depend on - # Frontend, we need an explicit dependency on Serialization too. - # [1] https://llvm.org/viewvc/llvm-project?view=revision&revision=348907 - # [2] https://llvm.org/viewvc/llvm-project?view=revision&revision=348915 - clangSerialization - ) - # Platform dependencies. if (WIN32) target_link_libraries(include-what-you-use @@ -124,9 +156,29 @@ endif() add_definitions(-DIWYU_GIT_REV="${IWYU_GIT_REV}") # Install programs -install(TARGETS include-what-you-use RUNTIME DESTINATION bin) -install(PROGRAMS fix_includes.py iwyu_tool.py DESTINATION bin) +include(GNUInstallDirs) +install(TARGETS include-what-you-use RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) +install(PROGRAMS fix_includes.py iwyu_tool.py DESTINATION ${CMAKE_INSTALL_BINDIR}) # Install mapping files file(GLOB MAPPING_FILES *.imp) -install(FILES ${MAPPING_FILES} DESTINATION share/include-what-you-use) +install(FILES ${MAPPING_FILES} DESTINATION ${CMAKE_INSTALL_DATADIR}/include-what-you-use) + +# Install man page on Unix-like systems +if (UNIX) + install(FILES include-what-you-use.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1) +endif() + +find_package(PythonInterp) +if(PYTHONINTERP_FOUND) + enable_testing() + add_test(NAME iwyu_tests + COMMAND ${PYTHON_EXECUTABLE} run_iwyu_tests.py -- $ + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) + add_test(NAME fix_includes_test + COMMAND ${PYTHON_EXECUTABLE} fix_includes_test.py + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) + add_test(NAME iwyu_tool_test + COMMAND ${PYTHON_EXECUTABLE} iwyu_tool_test.py + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) +endif() diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 41943af..322e7f0 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -4,13 +4,15 @@ We welcome patches and rely on your contributions to make IWYU smarter. +Coding and testing guidelines are available in the [IWYU Coding Style](docs/IWYUStyle.md) guide. + Use GitHub's [pull request system](https://github.com/include-what-you-use/include-what-you-use/pulls) to submit change requests to the `include-what-you-use/include-what-you-use` repo. It's usually a good idea to run ideas by the [IWYU mailing list](http://groups.google.com/group/include-what-you-use) to get general agreement on directions before you start hacking. ## Running the Tests ## -If fixing a bug in clang, please add a test to the test suite! You can create a file called `whatever.cc` (_not_ .cpp), and, if necessary, `whatever.h`, and `whatever-.h`. You may be able to get away without adding any `.h` files, and just including `direct.h` -- see, for instance, `tests/remove_fwd_decl_when_including.cc`. +If fixing a bug in IWYU, please add a test to the test suite! You can create a file called `whatever.cc` (_not_ .cpp), and, if necessary, `whatever.h`, and `whatever-.h`. You may be able to get away without adding any `.h` files, and just including `direct.h` -- see, for instance, `tests/remove_fwd_decl_when_including.cc`. To run the IWYU tests, run diff --git a/README.md b/README.md index e107a84..24ff71c 100644 --- a/README.md +++ b/README.md @@ -18,11 +18,29 @@ While we work to get IWYU quality up, we will be stinting new features, and will ### How to Build ### -Include-what-you-use makes heavy use of Clang internals, and will occasionally break when Clang is updated. Usually such discrepancies are detected by build bot and fixed promptly. The master branch follows Clang trunk. +Include-what-you-use makes heavy use of Clang internals, and will occasionally break when Clang is updated. Usually such discrepancies are detected by build bot and fixed promptly. + +**The IWYU master branch follows Clang trunk**. We also have convenience tags and branches for released versions of Clang (called `clang_`, e.g. `clang_5.0`). To build against a Clang release, check out the corresponding branch in IWYU before configuring the build. More details in the instructions below. -We assume you already have compiled LLVM and Clang libraries on your system, either via packages for your platform or built from source. +We assume you already have compiled LLVM and Clang libraries on your system, either via packages for your platform or built from source. You can use this mapping table to combine Clang and IWYU versions correctly: + +| Clang | IWYU version | IWYU branch | +|--------|--------------|----------------| +| 3.6 | 0.4 | `clang_3.6` | +| 3.7 | 0.5 | `clang_3.7` | +| 3.8 | 0.6 | `clang_3.8` | +| 3.9 | 0.7 | `clang_3.9` | +| 4.0 | 0.8 | `clang_4.0-r2` | +| 5.0 | 0.9 | `clang_5.0` | +| 6 | 0.10 | `clang_6.0` | +| 7 | 0.11 | `clang_7.0` | +| 8 | 0.12 | `clang_8.0` | +| 9 | 0.13 | `clang_9.0` | +| 10 | 0.14 | `clang_10` | +| ... | ... | ... | +| trunk | master | `master` | > NOTE: If you use the Debian/Ubuntu packaging available from , you'll need the following packages installed: > @@ -57,6 +75,8 @@ To set up an environment for building: # For IWYU 0.11/Clang 7 and later iwyu/build$ cmake -G "Unix Makefiles" -DCMAKE_PREFIX_PATH=/usr/lib/llvm-7 ../include-what-you-use + (substitute the `llvm-6.0` or `llvm-7` suffixes with the actual version compatible with your IWYU branch) + or, if you have a local LLVM and Clang build tree, you can specify that as `CMAKE_PREFIX_PATH` for IWYU 0.11 and later: iwyu/build$ cmake -G "Unix Makefiles" -DCMAKE_PREFIX_PATH=/llvm-trunk/build ../include-what-you-use diff --git a/boost-1.64-all-private.imp b/boost-1.64-all-private.imp index 5f32299..439e4d2 100644 --- a/boost-1.64-all-private.imp +++ b/boost-1.64-all-private.imp @@ -1,15 +1,13 @@ [ -#grep -r '^ *# *include' boost/ | grep -e "boost/[^:]*/detail/.*hp*:" -e "boost/[^:]*/impl/.*hp*:" | grep -e "\:.*/detail/" -e "\:.*/impl/" | perl -nle 'm/^([^:]+).*["<]([^>]+)[">]/ && print qq@ { include: ["<$2>", private, "<$1>", private ] },@' | grep -e \\[\"\", private, "", private ] }, -# { include: ["", private, "", private ] }, -# -# { include: ["", private, "", private ] }, -# { include: ["", private, "", private ] }, -# { include: ["", private, "", private ] }, -# { include: ["", private, "", private ] }, +# grep -r '^ *# *include' boost/ | grep -e "boost/[^:]*/detail/.*hp*:" -e "boost/[^:]*/impl/.*hp*:" | grep -e "\:.*/detail/" -e "\:.*/impl/" | perl -nle 'm/^([^:]+).*["<]([^>]+)[">]/ && print qq@ { include: ["<$2>", private, "<$1>", private ] },@' | grep -e \\[\"\", private, "", private ] }, { include: ["", private, "", private ] }, @@ -4360,10 +4358,6 @@ { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, - { include: ["", private, "", private ] }, - { include: ["", private, "", private ] }, - { include: ["", private, "", private ] }, - { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, @@ -4372,9 +4366,7 @@ { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, - { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, - { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, @@ -4914,10 +4906,6 @@ { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, - { include: ["", private, "", private ] }, - { include: ["", private, "", private ] }, - { include: ["", private, "", private ] }, - { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, @@ -5287,7 +5275,6 @@ { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, - { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, { include: ["", private, "", private ] }, diff --git a/boost-1.64-all.imp b/boost-1.64-all.imp index 7d75110..ef4e428 100644 --- a/boost-1.64-all.imp +++ b/boost-1.64-all.imp @@ -6,7 +6,7 @@ { include: ["@", private, "", public ] }, { include: ["@", private, "", public ] }, #manually delete $ sed '/workarounds*\.hpp/d' -i boost-all.imp -#also good idea to remove all lines refering to folders above (e.g., sed '/\/format\//d' -i boost-all.imp) +#also good idea to remove all lines refering to directories above (e.g., sed '/\/format\//d' -i boost-all.imp) #programatically include: { include: ["", private, "", public ] }, { include: ["", private, "", public ] }, diff --git a/boost-all.imp b/boost-all.imp index d0d87a8..946e453 100644 --- a/boost-all.imp +++ b/boost-all.imp @@ -6,7 +6,7 @@ { include: ["@", private, "", public ] }, { include: ["@", private, "", public ] }, #manually delete $ sed '/workarounds*\.hpp/d' -i boost-all.imp -#also good idea to remove all lines refering to folders above (e.g., sed '/\/format\//d' -i boost-all.imp) +#also good idea to remove all lines refering to directories above (e.g., sed '/\/format\//d' -i boost-all.imp) #programatically include: { include: ["", private, "", public ] }, { include: ["", private, "", public ] }, diff --git a/docs/IWYUStyle.md b/docs/IWYUStyle.md new file mode 100644 index 0000000..f556f2b --- /dev/null +++ b/docs/IWYUStyle.md @@ -0,0 +1,286 @@ +# IWYU Coding Style # + +IWYU is developed by a small number of loosely knit maintainers, and we rely on +external contributions to stand a chance to improve the tool. + +We use code reviews as a stage gate for every patch, via the GitHub pull request +system. We try our best to make reviews constructive and avoid power struggles, +so please accept feedback in the good faith it was delivered. + +This document describes the most important of the conventions that contributors +are expected to follow, so as to help make code reviews more productive and the +code base more consistent and maintainable. + +## Git workflow ## + +We prefer a linear history on the master branch, so we use a rebase workflow and +avoid merge commits. + +To post a pull request: + +* Fork the `include-what-you-use` repository on GitHub +* Clone your fork +* Create a topic branch in your clone +* Make changes +* Push branch to your fork +* Create pull request against the main repo + +To address review feedback: + +* Make changes in your branch +* Rewrite history in your branch to the way you want the final commit series. No + use to keep incremental review feedback as separate commits; we're only + interested in what the change set as a whole will look like. +* Make sure your branch is rebased on top of the latest upstream master and all + tests pass +* Force-push to your fork. This will update the pull request for the next round + of review. + +Note that it's fine to rewrite history of throw-away branches such as pull +request branches. If you need a more stable history for some reason (sharing +with other developers, tagging, etc), use a dedicated branch for the pull +request so you're free to rebase and amend it based on review feedback. + +There's no strong convention or tooling for commit messages (yet), but please +see https://chris.beams.io/posts/git-commit/ for set of guidelines to make the +Git log a nice place to visit. + +## License headers ## + +Every source file must have a license header on the form: + +``` +//===--- - ---------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +``` + +(With the corresponding comment prefix/suffix for other languages.) + +There is a utility script, `iwyu-check-license-header.py` that can be used to +automatically add a license header with the right filename to a new source file. + +## C++ ## + +IWYU originated within Google, so its basic style is based on what Google had in +their style guide at that time. Please refer to the [Google C++ style guide][1] +for details, but note that newer decisions may not apply to IWYU. The most +important points: + +* At most 80 characters per line +* 2 spaces indentation, 4 spaces for continued lines +* Unix line endings +* PascalCase for types and functions, hacker_case for variables, + LOUDMOUTH_CASE for macros +* Pointer asterisk and reference ampersand binds to the type name, not the + declared variable (i.e. declarations look like `Foo* f;` and `Bar& b;`) +* When in doubt, mimic the code around you. + +IWYU has a `.clang-format` file, so everything should play out nicely if you use +clang-format on your edited lines. PLEASE do not reformat more than lines you +touch, especially not whole files. The git-clang-format tool can help with this. + +We observe a few [LLVM-inspired rules][2] for IWYU: + +* **Use 'auto' sparingly** -- we don't subscribe to the "Almost always auto" +guideline in IWYU. In line with LLVM tradition we use `auto` when it improves +readability, and take that to mean when the type is already clearly visible on +the line (e.g. `const auto& d = cast(b);`) or when iterator +declarations would grow too unwieldy (e.g. `const auto i = some_map.begin();`). + +* **Prefer 'static' to anonymous namespaces** -- while `static` is decidedly a +C-ism, we find it's a readability win compared to anonymous namespaces to mark +functions for internal linkage. The LLVM coding standards make the argument +well, so no use to repeat it here. + +Other than that, we mostly follow mainstream C++ style, if there is such a +thing. + + +## Python ## + +Older IWYU Python code follows the [Google convention for Python code][3], but +newer scripts typically just use [PEP8][4]. + +Again, mimic the code around you. + + +## Regression tests ## + +IWYU uses a regression testing framework purpose-built to verify IWYU +diagnostics. + +There are a few conventions for IWYU testcases we use to keep the test suite +maintainable and effective. Note that we have many tests breaking these +guidelines, but that's considered a bug that we will work on over time. + +### Testcase per construct ### + +IWYU started out with one single testcase -- `badinc.cc` -- to cover all aspects +of IWYU. This has proved hard to maintain, as many assertions are subtly +interconnected and it can be difficult to map a test failure back to the feature +that triggered it. + +Now that IWYU handles most of the basics, we try to add new testcases organized +by the language construct or IWYU feature they cover. This tends to produce a +large number of testcases, and we'll probably have to go back and organize them +further at some point. + +Some things to keep in mind: + +* Keep testcase filenames short -- this is a case of "as short as possible, but + no shorter". Every file has its name in the license header, the stem is + repeated for supporting headers, and testcase names occasionally need to be + typed without completion, so it's nice if they're short and sweet. But they + also need to be meaningful. Find the balance. +* If a change pertains to a feature covered by an existing testcase, consider + extending it instead of creating a new one. +* Don't use another testcase's supporting headers; that creates unwanted + coupling between tests. But see below for a set of headers we do encourage + sharing. + +### Reusable headers ### + +Prefer the reusable headers for simple constructs. + +The test stack contains a few headers aimed for reuse: + +* `indirect.h` -- defines `IndirectClass`, a very basic C++ class +* `direct.h` -- includes `indirect.h` +* `subdir/indirect_subdir.h` -- defines `IndirectSubDirClass` +* `subdir/direct_subdir.h` -- includes `subdir/indirect_subdir.h` +* `subdir/dotdot_indirect.h` -- includes `../indirect.h` + +If you need a basic class as a return type, argument type, variable or template +argument, `IndirectClass` should be your preference. + +The `direct*.h` variants are used to force IWYU to do its analysis and +replacement; it will suggest that you remove `direct.h` and include `indirect.h` +directly. More on this below. + +The `subdir/` headers can be used to test that IWYU is not confused by directory +structure (which has been known to happen). + +### Avoid system headers ### + +Avoid using system headers for regression tests. + +It's tempting to phrase your testcase in terms of the library that triggered a +bug. But our test runners do not have all libraries installed. The C++ standard +library is a non-obvious example of this: it's always available, but IWYU aims +to be portable, and standard library _implementations_ differ wildly. + +For example, if `std::map` triggers a bad behavior with IWYU on your MSVC system +because it uses some template trick in its implementation, it's likely libstdc++ +or libc++ do not use the same trick, and exhibit different behavior. + +Likewise, the internal physical design details of standard library +implementations are usually wildly different -- libstdc++ has all its private +headers in a directory called `bits/`, MSVC prefixes all private library headers +with `x`, e.g. `xstring`, etc. IWYU uses mappings to overcome these differences. + +Since we can't control what standard library IWYU will be tested with, we prefer +to avoid standard library types and headers as far as possible, and instead try +to reduce constructs that cause problems to a minimal mockup. Clang takes a +similar approach in its test suite. + +Note that many of IWYU's older tests *do* use system headers, and as a +consequence we have incidental failures on many non-Linux platforms. + +### Fail first ### + +When making changes, make sure your testcases fail without your changes, and +pass with them. This is an easy way to make sure your tests cover the right +thing. + +### Force diagnostics ### + +Use IWYU diagnostics for more fine-grained testing. + +It's tempting to write a test such that it satisfies all IWYU rules and produces +a `(x.cc has correct #includes/fwd-decls)` message. + +But it's usually better to use the reusable headers to force some churn. Besides +the summary output at the end ("should add/should remove/full include list"), +IWYU also emits helpful diagnostics at the point of every use, e.g. + +* `warning: X is defined in "tests/cxx/x.h", which isn't directly #included` +* `warning: X needs a declaration, but does not provide or directly #include...` + +The test framework has native pattern matching support for these diagnostics, to +make it easier to check that IWYU triggers where expected and doesn't suggest +keeping a header for some unrelated reason. + +Therefore, prefer to include `direct.h` when you need `IndirectClass` (or the +corresponding per-testcase header) to force a diagnostic on use. + +### Header names ### + +Where the reusable headers are not enough, use per-test headers with a special +naming convention. + +In order to be able to force diagnostics, it's typically best to split +supporting headers into a direct and indirect pair. For a testcase named `x.cc`, +these would be named: + +* `x-indirect.h` for a header containing symbol declarations +* `x-direct.h` for a header including `x-indirect.h` + +If you need more than one header, use `-i` and `-d` for suffixes: + +* `x-i1.h` and `x-i2.h` for headers containing symbol declarations +* `x-d1.h` for a header including `x-i1.h` +* `x-d2.h` for a header including `x-i2.h` + +Depending on the complexity of your testcase, you can usually use a single +`-direct.h` header for multiple `-i.h` headers. + +It's a good idea to keep the number of headers in a single testcase small, but +some tests require more. + +Also, beware of the associated header -- if you use a header `x.h` for testcase +`x.cc`, IWYU will identify it as an associated header and analysis will be +slightly different. That can be used to simplify testing, but it can also +produce results that aren't necessarily the same for non-associated headers. + +### Symbol names ### + +Name symbols after their role or what sets them apart in the test. + +And from the other perspective: don't name symbols for testing after their +containing header file. + +If it's important that a type is a template, name it `Template`. If the defining +trait of a class from IWYU's perspective is that it's nested in another class, +name it `Nested`, etc. + +With the direct/indirect naming convention for headers, attempting to match up +symbol and header names turns into an exercise in obscurity, and we prefer clear +and communicative names. + +Keeping strictly separate naming schemes for test symbols and headers also makes +it easier to rename things without throwing Git's content tracking for a loop. + +### Command-line arguments ### + +If a test needs to pass additional command-line args to IWYU, they are coded +into `run_iwyu_tests.py`. There are three flag mappings: + +* `flags_map` -- for IWYU flags, e.g. `--no_comments` (automatically prefixed + with `-Xiwyu`) +* `clang_flags_map` -- for Clang flags, e.g. `-std=c++17` +* `include_map` -- additional header search paths, e.g. `subdir/` (automatically + prefixed with `-I`) + +The maps are all keyed by test file basename. + + +[1]: https://google.github.io/styleguide/cppguide.html +[2]: https://llvm.org/docs/CodingStandards.html +[3]: https://google.github.io/styleguide/pyguide.html +[4]: https://www.python.org/dev/peps/pep-0008 diff --git a/fix_includes.py b/fix_includes.py index d22737e..7600361 100755 --- a/fix_includes.py +++ b/fix_includes.py @@ -135,7 +135,7 @@ _IWYU_PRAGMA_ASSOCIATED_RE = re.compile(r'IWYU\s*pragma:\s*associated') # we fold _C_COMMENT_START_RE and _C_COMMENT_END_RE into _COMMENT_LINE_RE. # The _NAMESPACE_CONTINUE_ALLMAN_MIXED_RE is also set on lines when Allman # and mixed namespaces are detected but the RE is too easy to match to add -# under normal circumstances (must always be proceded by Allman/mixed). +# under normal circumstances (must always be preceded by Allman/mixed). _LINE_TYPES = [_COMMENT_LINE_RE, _BLANK_LINE_RE, _NAMESPACE_START_RE, _NAMESPACE_START_ALLMAN_RE, _NAMESPACE_START_MIXED_RE, _NAMESPACE_END_RE, @@ -235,6 +235,10 @@ class IWYUOutputRecord(object): # report, though, forward-declares inside '#if 0' or similar.) self.seen_forward_declare_lines = set() + # Those spans which pertain to nested forward declarations (i.e. of nested + # classes). This set should be a subset of self.seen_forward_declare_lines. + self.nested_forward_declare_lines = set() + # A set of each line in the iwyu 'add' section. self.includes_and_forward_declares_to_add = OrderedSet() @@ -261,6 +265,7 @@ class IWYUOutputRecord(object): self.lines_to_delete.intersection_update(other.lines_to_delete) self.some_include_lines.update(other.some_include_lines) self.seen_forward_declare_lines.update(other.seen_forward_declare_lines) + self.nested_forward_declare_lines.update(other.nested_forward_declare_lines) self.includes_and_forward_declares_to_add.update( other.includes_and_forward_declares_to_add) self.full_include_lines.update(other.full_include_lines) @@ -443,8 +448,10 @@ class IWYUOutputParser(object): continue m = self._LINE_NUMBERS_COMMENT_RE.search(line) if m: - retval.seen_forward_declare_lines.add((int(m.group(1)), - int(m.group(2))+1)) + line_range = (int(m.group(1)), int(m.group(2))+1) + retval.seen_forward_declare_lines.add(line_range) + if '::' in line: + retval.nested_forward_declare_lines.add(line_range) # IWYUOutputRecord.includes_and_forward_declares_to_add for line in self.lines_by_section.get(self._ADD_SECTION_RE, []): @@ -503,6 +510,10 @@ class LineInfo(object): # of the class/struct. For other types of lines, this is None. self.key = None + # If this is a forward-declaration of a nested class, then this will be + # True. + self.is_nested_forward_declaration = False + def __str__(self): if self.deleted: line = 'XX-%s-XX' % self.line @@ -771,6 +782,13 @@ def _CalculateLineTypesAndKeys(file_lines, iwyu_record): % (iwyu_record.filename, line_number)) file_lines[line_number].type = _FORWARD_DECLARE_RE + for (start_line, end_line) in iwyu_record.nested_forward_declare_lines: + for line_number in range(start_line, end_line): + if line_number >= len(file_lines): + raise FixIncludesError('iwyu line number %s:%d is past file-end' + % (iwyu_record.filename, line_number)) + file_lines[line_number].is_nested_forward_declaration = True + # While we're at it, let's do a bit more sanity checking on iwyu_record. for line_number in iwyu_record.lines_to_delete: if line_number >= len(file_lines): @@ -1281,7 +1299,8 @@ def _ShouldInsertBlankLine(decorated_move_span, next_decorated_move_span, def _GetToplevelReorderSpans(file_lines): - """Returns a sorted list of all reorder_spans not inside an #ifdef/namespace. + """Returns a sorted list of all reorder_spans not inside an + #ifdef/namespace/class. This routine looks at all the reorder_spans in file_lines, ignores reorder spans inside #ifdefs and namespaces -- except for the 'header @@ -1337,7 +1356,8 @@ def _GetToplevelReorderSpans(file_lines): good_reorder_spans = [] for reorder_span in reorder_spans: for line_number in range(*reorder_span): - if in_ifdef[line_number] or in_namespace[line_number]: + if (in_ifdef[line_number] or in_namespace[line_number] or + file_lines[line_number].is_nested_forward_declaration): break else: # for/else good_reorder_spans.append(reorder_span) # never in ifdef or namespace @@ -1571,8 +1591,8 @@ def _IsMainCUInclude(line_info, filename): return True # First, normalize the includee by getting rid of -inl.h and .h # suffixes (for the #include) and the "'s around the #include line. - canonical_include = re.sub(r'(-inl\.h|\.h|\.H)$', - '', line_info.key.replace('"', '')) + canonical_include = re.sub(r'(-inl\.h|\.h|\.hpp)$', '', + line_info.key.replace('"', ''), flags=re.I) # Then normalize includer by stripping extension and Google's test suffixes. canonical_file, _ = os.path.splitext(filename) canonical_file = re.sub(r'(_unittest|_regtest|_test)$', '', canonical_file) diff --git a/fix_includes_test.py b/fix_includes_test.py index 36a567d..380da54 100755 --- a/fix_includes_test.py +++ b/fix_includes_test.py @@ -2945,6 +2945,34 @@ template class B; // lines 4-5 self.RegisterFileContents({'dont_remove_template_lines': infile}) self.ProcessAndTest(iwyu_output) + def testDontRemoveSimilarNestedDeclarations(self): + """Tests we don't accidentally think repeated nested forward declarations + are dupes.""" + infile = """\ +#include ///- + +class A { + class Inner; +}; + +class B { + class Inner; +}; +""" + iwyu_output = """\ +dont_remove_similar_nested should add these lines: + +dont_remove_similar_nested should remove these lines: +- #include // lines 1-1 + +The full include-list for dont_remove_similar_nested: +class A::Inner; // lines 4-4 +class B::Inner; // lines 8-8 +--- +""" + self.RegisterFileContents({'dont_remove_similar_nested': infile}) + self.ProcessAndTest(iwyu_output) + def testNestedNamespaces(self): infile = """\ // Copyright 2010 @@ -3766,6 +3794,41 @@ The full include-list for barrier_includes.h: expected_output = """\ #include "foo.H" #include +""" + self.RegisterFileContents({'foo.cc': infile}) + num_files_modified = fix_includes.SortIncludesInFiles( + ['foo.cc'], self.flags) + self.assertListEqual(expected_output.splitlines(True), + self.actual_after_contents) + self.assertEqual(1, num_files_modified) + + def testSortingMainCUIncludeWithHpp(self): + """Check that we identify when first .hpp file is a main-cu #include.""" + infile = """\ +#include +#include "foo.hpp" +""" + expected_output = """\ +#include "foo.hpp" +#include +""" + self.RegisterFileContents({'foo.cc': infile}) + num_files_modified = fix_includes.SortIncludesInFiles( + ['foo.cc'], self.flags) + self.assertListEqual(expected_output.splitlines(True), + self.actual_after_contents) + self.assertEqual(1, num_files_modified) + + def testSortingMainCUIncludeWithMixedCaseInl(self): + """Check that we identify when first -inl.hpp file with mixed case + is a main-cu #include.""" + infile = """\ +#include +#include "foo-InL.h" +""" + expected_output = """\ +#include "foo-InL.h" +#include """ self.RegisterFileContents({'foo.cc': infile}) num_files_modified = fix_includes.SortIncludesInFiles( diff --git a/gcc.libc.imp b/gcc.libc.imp index 66e9fdb..1d436f5 100644 --- a/gcc.libc.imp +++ b/gcc.libc.imp @@ -97,6 +97,7 @@ { include: [ "", private, "", private ] }, { include: [ "", private, "", private ] }, { include: [ "", private, "", public ] }, + { include: [ "", private, "", public ] }, { include: [ "", private, "", public ] }, { include: [ "", private, "", public ] }, { include: [ "", private, "", public ] }, diff --git a/gcc.symbols.imp b/gcc.symbols.imp index 9f498d8..614cb56 100644 --- a/gcc.symbols.imp +++ b/gcc.symbols.imp @@ -57,6 +57,7 @@ { symbol: [ "intptr_t", private, "", public ] }, { symbol: [ "key_t", private, "", public ] }, { symbol: [ "key_t", private, "", public ] }, + { symbol: [ "max_align_t", private, "", public ] }, { symbol: [ "mode_t", private, "", public ] }, { symbol: [ "mode_t", private, "", public ] }, { symbol: [ "mode_t", private, "", public ] }, @@ -77,6 +78,7 @@ { symbol: [ "pid_t", private, "", public ] }, { symbol: [ "pid_t", private, "", public ] }, { symbol: [ "pid_t", private, "", public ] }, + { symbol: [ "ptrdiff_t", private, "", public ] }, { symbol: [ "sigset_t", private, "", public ] }, { symbol: [ "sigset_t", private, "", public ] }, { symbol: [ "sigset_t", private, "", public ] }, @@ -105,6 +107,8 @@ { symbol: [ "uid_t", private, "", public ] }, { symbol: [ "useconds_t", private, "", public ] }, { symbol: [ "useconds_t", private, "", public ] }, + { symbol: [ "wchar_t", private, "", public ] }, + { symbol: [ "wchar_t", private, "", public ] }, # glob.h seems to define size_t if necessary, but it should come from stddef. { symbol: [ "size_t", private, "", public ] }, { symbol: [ "size_t", private, "", public ] }, diff --git a/generate_qt_mappings.py b/generate_qt_mappings.py new file mode 100755 index 0000000..3c45237 --- /dev/null +++ b/generate_qt_mappings.py @@ -0,0 +1,170 @@ +#!/usr/bin/env python + +##===--- generate_qt_mappings.py ------------------------------------------===## +# +# The LLVM Compiler Infrastructure +# +# This file is distributed under the University of Illinois Open Source +# License. See LICENSE.TXT for details. +# +##===----------------------------------------------------------------------===## + +""" +This script generates the Qt mapping file according to given Qt include +directory + +Example usage : + + $ ./generate_qt_mappings.py /usr/include/x86_64-linux-gnu/qt5 qt5_11.imp + +""" + +from __future__ import print_function +import argparse +import glob +import json +import os +import re +import sys + + +OUTFILEHDR = ("# Do not edit! This file was generated by the script %s." % + os.path.basename(__file__)) + +QOBJECT_SYMBOLS = [ + "QObjectList", + "qFindChildren", + "qobject_cast", + "QT_NO_NARROWING_CONVERSIONS_IN_CONNECT", + "Q_CLASSINFO", + "Q_DISABLE_COPY", + "Q_DISABLE_COPY_MOVE", + "Q_DISABLE_MOVE", + "Q_EMIT", + "Q_ENUM", + "Q_ENUM_NS", + "Q_FLAG", + "Q_FLAG_NS", + "Q_GADGET", + "Q_INTERFACES", + "Q_INVOKABLE", + "Q_NAMESPACE", + "Q_NAMESPACE_EXPORT", + "Q_OBJECT", + "Q_PROPERTY", + "Q_REVISION", + "Q_SET_OBJECT_NAME", + "Q_SIGNAL", + "Q_SIGNALS", + "Q_SLOT", + "Q_SLOTS", + "emit", + "slots", + "signals", + "SIGNAL", + "SLOT", +] + + +class QtHeader(object): + """ Carry data associated with a Qt header """ + def __init__(self, headername): + self.headername = headername + self.classname = os.path.basename(headername) + self.modulename = os.path.basename(os.path.dirname(headername)) + self._private_headers = None + + def get_private_headers(self): + """ Return a list of headernames included by this header """ + if self._private_headers is None: + with open(self.headername, 'r') as headerfile: + included = re.findall(r'#include "(.*)\.h"', headerfile.read()) + self._private_headers = list(included) + return self._private_headers + + +def build_imp_lines(symbols_map, includes_map): + """ Generate a big string containing the mappings in .imp format. + + This should ideally return a jsonable structure instead, and use json.dump + to write it to the output file directly. But there doesn't seem to be a + simple way to convince Python's json library to generate a "packed" + formatting, it always prefers to wrap dicts onto multiple lines. + + Cheat, and use json.dumps for escaping and build a string instead. + """ + root = [] + + def jsonline(mapping): + return " " + json.dumps(mapping) + + for symbol, header in symbols_map: + map_to = "<" + header + ">" + root.append(jsonline({"symbol": [symbol, "private", map_to, "public"]})) + + for module, include, header in includes_map: + # Use regex map-from to match both quoted and angled includes and + # optional directory prefix (e.g. is equivalent to + # "qnamespace.h"). + map_from = r'@["<](%s/)?%s\.h[">]' % (module, include) + map_to = "<" + header + ">" + root.append(jsonline({"include": [map_from, "private", + map_to, "public"]})) + + lines = "[\n" + lines += ",\n".join(root) + lines += "\n]\n" + return lines + + +def add_mapping_rules(header, symbols_map, includes_map): + """ Add symbol and include mappings for a Qt module. """ + symbols_map += [(header.classname, header.classname)] + for include in header.get_private_headers(): + includes_map += [(header.modulename, include, header.classname)] + + +def main(qt_include_dir, output_file): + """ Entry point. """ + symbols_map = [] + includes_map = [] + deferred_headers = [] + + # Add manual overrides. + symbols_map += [("qDebug", "QtGlobal")] + symbols_map += [(symbol, "QObject") for symbol in QOBJECT_SYMBOLS] + includes_map += [("QtCore", "qnamespace", "Qt")] + + # Collect mapping information from Qt directory tree. + headers = glob.glob(os.path.join(qt_include_dir, '**/*[!.h]')) + for header in headers: + if os.path.isdir(header): + continue + + header = QtHeader(header) + if header.classname == "QInternal": + continue + + if header.classname == header.modulename: + deferred_headers.append(header) + else: + add_mapping_rules(header, symbols_map, includes_map) + + for header in deferred_headers: + add_mapping_rules(header, symbols_map, includes_map) + + # Transform to .imp-style format and write to output file. + lines = build_imp_lines(symbols_map, includes_map) + with open(output_file, 'w') as outfile: + print(OUTFILEHDR, file=outfile) + print(lines, file=outfile) + + return 0 + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("qt_include_dir", help="Qt include directoy") + parser.add_argument("output_file", help="Generated output mapping file") + args = parser.parse_args() + sys.exit(main(args.qt_include_dir, args.output_file)) diff --git a/include-what-you-use.1 b/include-what-you-use.1 new file mode 100644 index 0000000..c9376c0 --- /dev/null +++ b/include-what-you-use.1 @@ -0,0 +1,282 @@ +.\" t -*- coding: UTF-8 -*- +.\" Man page for include-what-you-use +.\" +.\" This file is distributed under the University of Illinois Open Source +.\" License. See LICENSE.TXT for details. +.\" +.TH INCLUDE-WHAT-YOU-USE 1 "2019-11-02" include-what-you-use "User Commands" +.SH NAME +include-what-you-use \- analyze includes in C and C++ source files. +.SH SYNOPSIS +.SY include-what-you-use +.RB [ \-Xiwyu +.IR option "]\&.\|.\|. [" clang-options "] " file +.YS +.SH DESCRIPTION +\(lqInclude what you use\(rq means this: for every symbol (type, function, +variable, or macro) that you use in +.IR foo.cpp , +either +.IR foo.cpp " or " foo.h +should include a header file that exports the declaration of that symbol. +.B include-what-you-use +is a tool to analyze includes of source files to find +\(lqinclude-what-you-use\(rq violations, and suggest fixes for them. +.PP +The main goal of +.B include-what-you-use +is to remove superfluous includes. +It does this both by figuring out what includes are not actually needed for this +file (for both source and header files), and by replacing includes with forward +declarations when possible. +.SH OPTIONS +Options for +.B include-what-you-use +have to be preceded with +.BR \-Xiwyu . +All other options are interpreted as +.BR clang (1) +compiler options. +.TP +.BI \-\-check_also= glob +Print \(lqinclude-what-you-use\(rq-violation info for all files matching the +given glob pattern (in addition to the default of reporting for the input +source file and associated header files). +This flag may be specified multiple times to specify multiple glob patterns. +.TP +.B \-\-cxx17ns +Suggest the more concise syntax for nested namespaces introduced in C++17. +.TP +.BI \-\-keep= glob +Always keep the includes matched by +.IR glob . +This flag may be used multiple times to specify more than one glob pattern. +.TP +.BI \-\-mapping_file= filename +Use the given mapping file. +.TP +.B \-\-max_line_length +Maximum line length for includes. +Note that this only affects the comments and their alignment, the maximum line +length can still be exceeded with long filenames (default: 80). +.TP +.B \-\-no_comments +Do not add comments after includes about which symbols the header was required +for. +.TP +.B \-\-no_default_mappings +Do not use the default mappings. +.TP +.B \-\-no_fwd_decls +Do not use forward declarations, and instead always include the required header. +.TP +.B \-\-pch_in_code +Mark the first include in a translation unit as a precompiled header. Use +.B \-\-pch_in_code +to prevent removal of necessary PCH includes. Although +.BR clang (1) +forces PCHs to be listed as prefix headers, the PCH-in-code pattern can be used +with +.BR gcc (1). +.TP +.BI \-\-prefix_header_includes= value +Controls how includes and forward declarations involving prefix headers should +be handled. +Prefix headers are files included via the command-line option +.BR -include . +This option specifies what to do if a prefix header makes includes or forward +declarations obsolete. +The following +.IR value s +are allowed: +.RS +.TP +.B add +New includes are added. This is the default. +.TP +.B keep +No new includes are added, existing ones are kept intact. +.TP +.B remove +No new includes are added, existing ones are removed. +.RE +.TP +.B \-\-quoted_includes_first +When sorting includes, place quoted includes first. +.TP +.B \-\-transitive_includes_only +Do not suggest that a file should add +.IR foo.h " unless " foo.h +is already visible in the file's transitive includes. +.TP +.BI \-\-verbose= level +Set verbosity. At the highest level, this will dump the AST of the source file +and explain all decisions. +.SH EXIT STATUS +.B include-what-you-use +always returns with a nonzero status code to make usage with +.BR make (1) +feasible. +.SH MAPPING FILES +Sometimes headers are not meant to be included directly, +and sometimes headers are guaranteed to include other headers. +Since this is hard to tell from the source code alone, +these relationships have to be provided via mapping files or pragma comments. +.PP +A mapping file consists of a comma-separated list of rules enclosed by square +brackets +.BR [] . +A rule can be any of the following: +.TP +.BI "{ include: [" header ", " header "] }" +Declares that instead of the first +.I header +the second can be used. +A header can appear on the left-hand side in multiple rules, +meaning that any of the right-hand side headers can be used instead. +.TP +.BI "{ symbol: [" symbol ", " header "] }" +Declares that to use a +.IR symbol , +a certain +.I header +should be included. +.TP +.BI "{ ref: " mapping-file " }" +Includes the contents of another +.IR mapping-file . +.PP +The descriptions of headers and symbols are as follows: +.TP +.IB "header\fR := " \(dq include-spec "\(dq, " visibility +Describes a header file. The +.I include-spec +specifies the header file and +.I visibility +specifies whether the header is +.BR public " or " private . +Private headers are not allowed to be included directly. +So every private header file should appear on the left-hand side of a mapping +at least once. +The visibility of a header file has to be the same for all rules it appears in! +.TP +.IB "include-spec\fR := " < system-header-file > \ + "\fR | " \e\(dq project-header-file \e\(dq +How the header is +.BR #include d +in a source file. +Quotation marks need to be escaped. +.TP +.IB "symbol\fR := " \(dq symbol-name "\(dq, " visibility +Describes a symbol, for example a type, function or macro. The +.I visibility +is ignored, by convention +.B private +is used. +.PP +Lines starting with +.B # +are treated as comments. +.SH PRAGMA COMMENTS +Pragma comments provide information about the relations between source and +header files and allow to whitelist or blacklist +.BR #include s +and forward declarations. +.PP +All arguments should be enclosed in quotation marks. +.TP +.B // IWYU pragma: keep +Used after +.B #include +directives or forward declarations it ensures that they won't be removed. +.TP +.B // IWYU pragma: export +Used after an +.B #include +directive it indicates that the current file is considered to be a provider of +the included file. +.TP +.BR "// IWYU pragma: begin_exports" , " // IWYU pragma: end_exports" +Has the same effect as the previous pragma comment, but applies to a range of +.BR #include s +instead of a single line. +.TP +.BR "// IWYU pragma: private" [ ", include \fIheader" ] +Indicates that the current file is considered private, +and (optionally) that any symbol will be provided by +.IR header . +.TP +.BI "// IWYU pragma: no_include " header +States that +.I header +should not be suggested for inclusion. +.TP +.BI "// IWYU pragma: no_forward_declare "symbol +States that +.I symbol +should not be forward-declared. +.TP +.BI "// IWYU pragma: friend " regex +Used in a private header, this indicates that all files matching +.I regex +are allowed to +.B #include +it. +.TP +.B // IWYU pragma: associated +Used in a source file after an +.B #include +directive, this marks the header as associated to the source file. +This is required if source and header filename differ in more than their ending. +Includes from an associated header are assumed in the source file. +.SH FILES +.I /usr/share/include-what-you-use +.RS +Directory containing the standard mapping files. +.SH BUGS +See the +.UR https://github.com/include-what-you-use/include-what-you-use/issues +issue tracker +.UE +on GitHub. +.SH EXAMPLE +The easiest way to run +.B include-what-you-use +over your codebase is to run +.PP +.RS +.EX +make \-k CC=include-what-you-use CXX=include-what-you-use +.EE +.RE +.PP +The program always exits with an error code, so the build system knows that it +didn't build an object file. Hence the need for +.BR -k . +It only analyzes source files built by +.BR make (1) +along with their corresponding header files. +If a project has a header file with no corresponding source file, +.B include-what-you-use +will ignore it unless you use the +.B \-\-check_also +option to add it for analysis together with a source file. +.PP +CMake has built-in support for +.B include-what-you-use +as of version 3.3. With the +.B CMAKE_CXX_INCLUDE_WHAT_YOU_USE +option, CMake runs it on every source file after compilation: +.PP +.RS +.EX +cmake \-DCMAKE_CXX_INCLUDE_WHAT_YOU_USE="include-what-you-use " .. +.EE +.RE +.PP +The option is supported for both C and C++, so use +.B CMAKE_C_INCLUDE_WHAT_YOU_USE +for C code. +.SH "SEE ALSO" +.BR clang (1), +.BR make (1) diff --git a/iwyu-check-license-header.py b/iwyu-check-license-header.py new file mode 100755 index 0000000..3651147 --- /dev/null +++ b/iwyu-check-license-header.py @@ -0,0 +1,277 @@ +#!/usr/bin/env python + +##===--- iwyu-check-license-header.py - check license headers -------------===## +# +# The LLVM Compiler Infrastructure +# +# This file is distributed under the University of Illinois Open Source +# License. See LICENSE.TXT for details. +# +##===----------------------------------------------------------------------===## + +from __future__ import print_function +import sys +import os +import re +import argparse + + +# This is used in selected functions to calculate the maximum length of filename +# and filler dashes. Not otherwise useful. +EMBELLISHMENTS = '//===--- ---===//' + +HDRFORMAT = """ +{c} +{c} The LLVM Compiler Infrastructure +{c} +{c} This file is distributed under the University of Illinois Open Source +{c} License. See LICENSE.TXT for details. +{c} +{t}===----------------------------------------------------------------------==={t} +""" + + +def make_hdrformat(one, two): + """ Materialize HDRFORMAT based on the one and two comment styles. + + The one and two args should be '#' and '##' or '//' and '//', respectively. + Returns a list of lines. + """ + r = HDRFORMAT.lstrip().format(c=one, t=two) + return r.splitlines() + + +def truncated(filename): + """ Truncate the filename with ellipsis if too long """ + maxlen = 80 - len(EMBELLISHMENTS) + trunclen = maxlen - 3 # ... + if len(filename) > maxlen: + filename = filename[:trunclen] + '...' + return filename + + +def make_license_header(filename, one, two): + """ Build a valid license header from filename and comment styles. + + The one and two args should be '#' and '##' or '//' and '//', respectively. + Returns a list of lines. + """ + assert len(two) == 2 + filename = os.path.basename(filename) + filename = truncated(filename) + + def dashes(): + c = 80 + c -= len(EMBELLISHMENTS) + c -= len(filename) + return '-' * c + + firstline = '%s===--- %s %s===%s' % (two, filename, dashes(), two) + return [firstline] + make_hdrformat(one, two) + + +def format_file_error(filename, *lines): + """ Format an error message from filename and lines """ + lines = list(lines) + lines[0] = '%s: %s' % (filename, lines[0]) + return os.linesep.join(lines) + + +def find_license_header(lines, two): + """ Return an index where the license header begins """ + if not lines: + return -1 + + for i, line in enumerate(lines): + # Allow leading blank lines and hash-bangs. + if not line or line.startswith('#!'): + continue + + # Besides those, the first line should be a license header. + if line.startswith(two + '==='): + break + + # If not, this fails the test entirely. + return -1 + + return i + + +class File(object): + """ Base class for a source file with a license header + + Do not use directly, instead use File.parse to instantiate a more derived + class. + + Derived classes must have three class variables: + + * one - One comment char ('#' for Python, '//' for C++) + * two - Two comment chars ('##' for Python, '//' for C++) + * pattern - a regex matching the first line in a license header + """ + def __init__(self, filename): + with open(filename, 'r') as fd: + content = fd.read() + + self.lines = list(content.splitlines()) + self.hdrindex = find_license_header(self.lines, self.two) + self.filename = filename + self.errors = [] + + @classmethod + def parse(_, filename): + """ Return an object derived from File to analyze license headers """ + _, ext = os.path.splitext(filename) + if ext == '.py': + klass = PythonFile + elif ext in ('.h', '.c', '.cc'): + klass = CxxFile + else: + return None + + return klass(filename) + + def has_license_header(self): + """ Return True if a license header has been found """ + return self.hdrindex != -1 + + def add_license_header(self): + """ Add license header to a file that doesn't have one. """ + assert not self.has_license_header() + + # Find insertion point + for p, line in enumerate(self.lines): + # Skip past leading blank lines and hash-bangs. + if line and not line.startswith('#!'): + break + + # Split the lines around the insertion point + if self.lines: + before, after = self.lines[:p], self.lines[p:] + else: + before, after = [], [] + + # Rebuild the contents with the license header in the middle + lines = before + if before and before[-1] != '': + lines += [''] + lines += make_license_header(self.filename, self.one, self.two) + if after and after[0] != '': + lines += [''] + lines += after + + # Write back out + with open(self.filename, 'wb') as fd: + fd.write('\n'.join(lines)) + fd.write('\n') + + def check_license_header(self): + """ Check that the header lines follow convention. + + Returns True if everything is OK, otherwise returns False and populates + self.errors with all found errors. + """ + if not self.has_license_header(): + self.file_error('No license header found') + return False + + hdrlines = self.lines[self.hdrindex:self.hdrindex+8] + + # First line has the most structure + line = hdrlines[0] + if len(line) != 80: + self.line_error( + 1, 'Bad header line length (expected: 80, was: %d)' % len(line), + " Header line: '%s'" % line) + + m = self.pattern.match(line) + if not m: + self.line_error(1, 'Bad header line', + " Expected: '%s'" % self.pattern.pattern, + " Actual: '%s'" % line) + else: + hfilename = truncated(m.group(1)) + xfilename = truncated(os.path.basename(self.filename)) + if hfilename != xfilename: + self.line_error(1, 'Bad header filename', + " Expected: '%s'" % xfilename, + " Actual: '%s'" % hfilename) + + # The following seven lines always follow the layout of HDRFORMAT. + hdrformat = make_hdrformat(self.one, self.two) + hdrlines = hdrlines[1:] + for lineno, (expected, actual) in enumerate(zip(hdrformat, hdrlines)): + if expected != actual: + self.line_error(lineno + 2, 'Bad header line', + " Expected: '%s'" % expected, + " Actual: '%s'" % actual) + + return not self.errors + + def file_error(self, *lines): + """ Log an error for the file """ + self.errors.append(format_file_error(self.filename, *lines)) + + def line_error(self, lineno, *lines): + """ Log an error for a specific line in the file """ + lines = list(lines) + lines[0] = '%s:%d: %s' % (self.filename, lineno, lines[0]) + self.errors.append(os.linesep.join(lines)) + + +class PythonFile(File): + """ Python file with license header """ + one = '#' + two = '##' + pattern = re.compile( + r'##===--- ([a-z0-9_.-]+) -[A-Za-z0-9_.,/# -{}]+===##') + + def __init__(self, filename): + super(PythonFile, self).__init__(filename) + + +class CxxFile(File): + """ C++ file with license header """ + one = '//' + two = '//' + pattern = re.compile( + r'//===--- ([a-z0-9_.-]+) -[A-Za-z0-9_.,/# -{}]+ [-* C+]+===//') + + def __init__(self, filename): + super(CxxFile, self).__init__(filename) + + +def main(filenames, add_if_missing): + """ Entry point. + + Checks license header of all filenames provided. + Returns zero if all license headers are OK, non-zero otherwise. + """ + errors = [] + for filename in filenames: + if os.path.isdir(filename): + continue + + checker = File.parse(filename) + if not checker: + # TODO: Consider printing a warning here in verbose mode. + continue + + if not checker.check_license_header(): + errors.extend(checker.errors) + + if add_if_missing and not checker.has_license_header(): + checker.add_license_header() + + for err in errors: + print(err) + + return len(errors) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser('IWYU license header checker') + parser.add_argument('filename', nargs='+') + parser.add_argument('--add', action='store_true') + args = parser.parse_args() + sys.exit(main(args.filename, args.add)) diff --git a/iwyu.cc b/iwyu.cc index 4889b3f..931d57b 100644 --- a/iwyu.cc +++ b/iwyu.cc @@ -89,7 +89,6 @@ #include // for swap, find, make_pair #include // for size_t -#include // for snprintf #include // for atoi, exit #include #include // for swap @@ -109,15 +108,15 @@ #include "iwyu_location_util.h" #include "iwyu_output.h" #include "iwyu_path_util.h" -#include "iwyu_use_flags.h" +#include "iwyu_port.h" // for CHECK_ // This is needed for // preprocessor_info().PublicHeaderIntendsToProvide(). Somehow IWYU // removes it mistakenly. #include "iwyu_preprocessor.h" // IWYU pragma: keep #include "iwyu_stl_util.h" #include "iwyu_string_util.h" +#include "iwyu_use_flags.h" #include "iwyu_verrs.h" -#include "port.h" // for CHECK_ #include "llvm/Support/Casting.h" #include "llvm/Support/raw_ostream.h" #include "clang/AST/ASTConsumer.h" @@ -136,6 +135,7 @@ #include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/FrontendAction.h" #include "clang/Lex/Preprocessor.h" +#include "clang/Lex/PreprocessorOptions.h" #include "clang/Sema/Sema.h" namespace clang { @@ -204,6 +204,7 @@ using clang::TemplateArgumentList; using clang::TemplateArgumentLoc; using clang::TemplateName; using clang::TemplateSpecializationType; +using clang::TemplateSpecializationTypeLoc; using clang::TranslationUnitDecl; using clang::Type; using clang::TypeLoc; @@ -230,12 +231,6 @@ using std::vector; namespace { -string IntToString(int i) { - char buf[64]; // big enough for any number - snprintf(buf, sizeof(buf), "%d", i); - return buf; -} - bool CanIgnoreLocation(SourceLocation loc) { // If we're in a macro expansion, we always want to treat this as // being in the expansion location, never the as-written location, @@ -325,17 +320,17 @@ class BaseAstVisitor : public RecursiveASTVisitor { void set_current_ast_node(ASTNode* an) { current_ast_node_ = an; } bool TraverseDecl(Decl* decl) { - if (current_ast_node_->StackContainsContent(decl)) + if (current_ast_node_ && current_ast_node_->StackContainsContent(decl)) return true; // avoid recursion - ASTNode node(decl, *GlobalSourceManager()); + ASTNode node(decl); CurrentASTNodeUpdater canu(¤t_ast_node_, &node); return Base::TraverseDecl(decl); } bool TraverseStmt(Stmt* stmt) { - if (current_ast_node_->StackContainsContent(stmt)) + if (current_ast_node_ && current_ast_node_->StackContainsContent(stmt)) return true; // avoid recursion - ASTNode node(stmt, *GlobalSourceManager()); + ASTNode node(stmt); CurrentASTNodeUpdater canu(¤t_ast_node_, &node); return Base::TraverseStmt(stmt); } @@ -344,9 +339,9 @@ class BaseAstVisitor : public RecursiveASTVisitor { if (qualtype.isNull()) return Base::TraverseType(qualtype); const Type* type = qualtype.getTypePtr(); - if (current_ast_node_->StackContainsContent(type)) + if (current_ast_node_ && current_ast_node_->StackContainsContent(type)) return true; // avoid recursion - ASTNode node(type, *GlobalSourceManager()); + ASTNode node(type); CurrentASTNodeUpdater canu(¤t_ast_node_, &node); return Base::TraverseType(qualtype); } @@ -368,9 +363,9 @@ class BaseAstVisitor : public RecursiveASTVisitor { if (typeloc.getAs()) { typeloc = typeloc.getUnqualifiedLoc(); } - if (current_ast_node_->StackContainsContent(&typeloc)) + if (current_ast_node_ && current_ast_node_->StackContainsContent(&typeloc)) return true; // avoid recursion - ASTNode node(&typeloc, *GlobalSourceManager()); + ASTNode node(&typeloc); CurrentASTNodeUpdater canu(¤t_ast_node_, &node); return Base::TraverseTypeLoc(typeloc); } @@ -378,7 +373,7 @@ class BaseAstVisitor : public RecursiveASTVisitor { bool TraverseNestedNameSpecifier(NestedNameSpecifier* nns) { if (nns == nullptr) return true; - ASTNode node(nns, *GlobalSourceManager()); + ASTNode node(nns); CurrentASTNodeUpdater canu(¤t_ast_node_, &node); if (!this->getDerived().VisitNestedNameSpecifier(nns)) return false; @@ -388,7 +383,7 @@ class BaseAstVisitor : public RecursiveASTVisitor { bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc nns_loc) { if (!nns_loc) // using NNSLoc::operator bool() return true; - ASTNode node(&nns_loc, *GlobalSourceManager()); + ASTNode node(&nns_loc); CurrentASTNodeUpdater canu(¤t_ast_node_, &node); // TODO(csilvers): have VisitNestedNameSpecifierLoc instead. if (!this->getDerived().VisitNestedNameSpecifier( @@ -398,7 +393,7 @@ class BaseAstVisitor : public RecursiveASTVisitor { } bool TraverseTemplateName(TemplateName template_name) { - ASTNode node(&template_name, *GlobalSourceManager()); + ASTNode node(&template_name); CurrentASTNodeUpdater canu(¤t_ast_node_, &node); if (!this->getDerived().VisitTemplateName(template_name)) return false; @@ -406,7 +401,7 @@ class BaseAstVisitor : public RecursiveASTVisitor { } bool TraverseTemplateArgument(const TemplateArgument& arg) { - ASTNode node(&arg, *GlobalSourceManager()); + ASTNode node(&arg); CurrentASTNodeUpdater canu(¤t_ast_node_, &node); if (!this->getDerived().VisitTemplateArgument(arg)) return false; @@ -414,7 +409,7 @@ class BaseAstVisitor : public RecursiveASTVisitor { } bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc& argloc) { - ASTNode node(&argloc, *GlobalSourceManager()); + ASTNode node(&argloc); CurrentASTNodeUpdater canu(¤t_ast_node_, &node); if (!this->getDerived().VisitTemplateArgumentLoc(argloc)) return false; @@ -449,7 +444,7 @@ class BaseAstVisitor : public RecursiveASTVisitor { // etc. string AnnotatedName(const string& name) const { return (PrintableCurrentLoc() + ": (" + - IntToString(current_ast_node_->depth()) + GetSymbolAnnotation() + + std::to_string(current_ast_node_->depth()) + GetSymbolAnnotation() + (current_ast_node_->in_forward_declare_context() ? ", fwd decl" : "") + ") [ " + name + " ] "); @@ -547,32 +542,10 @@ class BaseAstVisitor : public RecursiveASTVisitor { // // * CXXDestructorDecl: a destructor call for each non-POD field // in the dtor's class, and each base type of that class. - // * CXXConstructorDecl: a constructor call for each type/base - // of the class that is not explicitly listed in an initializer. // * CXXRecordDecl: a CXXConstructorDecl for each implicit // constructor (zero-arg and copy). A CXXDestructor decl // if the destructor is implicit. A CXXOperatorCallDecl if // operator= is explicit. - - bool TraverseCXXConstructorDecl(clang::CXXConstructorDecl* decl) { - if (!Base::TraverseCXXConstructorDecl(decl)) return false; - if (CanIgnoreCurrentASTNode()) return true; - // We only care about classes that are actually defined. - if (!decl || !decl->isThisDeclarationADefinition()) return true; - - // RAV's TraverseCXXConstructorDecl already handles - // explicitly-written initializers, so we just want the rest. - for (CXXConstructorDecl::init_const_iterator it = decl->init_begin(); - it != decl->init_end(); ++it) { - const CXXCtorInitializer* init = *it; - if (!init->isWritten()) { - if (!this->getDerived().TraverseStmt(init->getInit())) - return false; - } - } - return true; - } - bool TraverseCXXDestructorDecl(clang::CXXDestructorDecl* decl) { if (!Base::TraverseCXXDestructorDecl(decl)) return false; if (CanIgnoreCurrentASTNode()) return true; @@ -653,70 +626,21 @@ class BaseAstVisitor : public RecursiveASTVisitor { sema.PerformPendingInstantiations(); } - // clang doesn't bother to set a TypeSourceInfo for implicit - // methods, since, well, they don't have a location. But - // RecursiveASTVisitor crashes without one, so when we lie and say - // we're not implicit, we have to lie and give a location as well. - // (We give the null location.) This is a small memory leak. - void SetTypeSourceInfoForImplicitMethodIfNeeded(FunctionDecl* decl) { - if (decl->getTypeSourceInfo() == nullptr) { - ASTContext& ctx = compiler_->getASTContext(); - decl->setTypeSourceInfo(ctx.getTrivialTypeSourceInfo(decl->getType())); - } - } - - // RAV.h's TraverseDecl() ignores implicit nodes, so we lie a bit. - // TODO(csilvers): figure out a more principled way. - bool TraverseImplicitDeclHelper(clang::FunctionDecl* decl) { - CHECK_(decl->isImplicit() && "TraverseImplicitDecl is for implicit decls"); - decl->setImplicit(false); - SetTypeSourceInfoForImplicitMethodIfNeeded(decl); - bool retval = this->getDerived().TraverseDecl(decl); - decl->setImplicit(true); - return retval; - } - // Handle implicit methods that otherwise wouldn't be seen by RAV. bool TraverseCXXRecordDecl(clang::CXXRecordDecl* decl) { - if (!Base::TraverseCXXRecordDecl(decl)) return false; if (CanIgnoreCurrentASTNode()) return true; // We only care about classes that are actually defined. - if (!decl || !decl->isThisDeclarationADefinition()) return true; - - InstantiateImplicitMethods(decl); - - // Check to see if there are any implicit constructors. Can be - // several: implicit default constructor, implicit copy constructor. - for (CXXRecordDecl::ctor_iterator it = decl->ctor_begin(); - it != decl->ctor_end(); ++it) { - CXXConstructorDecl* ctor = *it; - if (ctor->isImplicit() && !ctor->isDeleted()) { - if (!TraverseImplicitDeclHelper(ctor)) - return false; - } - } - - // Check the (single) destructor. - bool has_implicit_declared_destructor = - (!decl->needsImplicitDestructor() && - !decl->hasUserDeclaredDestructor()); - if (has_implicit_declared_destructor) { - if (!TraverseImplicitDeclHelper(decl->getDestructor())) - return false; + if (decl && decl->isThisDeclarationADefinition()) { + InstantiateImplicitMethods(decl); } - // Check copy and move assignment operators. - for (CXXRecordDecl::method_iterator it = decl->method_begin(); - it != decl->method_end(); ++it) { - bool is_assignment_operator = - it->isCopyAssignmentOperator() || it->isMoveAssignmentOperator(); - if (is_assignment_operator && it->isImplicit()) { - if (!TraverseImplicitDeclHelper(*it)) - return false; - } - } + return Base::TraverseCXXRecordDecl(decl); + } - return true; + bool TraverseClassTemplateSpecializationDecl( + clang::ClassTemplateSpecializationDecl* decl) { + if (!Base::TraverseClassTemplateSpecializationDecl(decl)) return false; + return TraverseCXXRecordDecl(decl); } //------------------------------------------------------------ @@ -840,8 +764,6 @@ class BaseAstVisitor : public RecursiveASTVisitor { !IsCXXConstructExprInInitializer(current_ast_node()) && !IsCXXConstructExprInNewExpr(current_ast_node()); if (will_call_implicit_destructor_on_leaving_scope) { - // Create the destructor if it hasn't been lazily created yet. - InstantiateImplicitMethods(expr->getConstructor()->getParent()); if (const CXXDestructorDecl* dtor_decl = GetSiblingDestructorFor(expr)) { if (!this->getDerived().TraverseImplicitDestructorCall( const_cast(dtor_decl), GetTypeOf(expr))) @@ -856,7 +778,6 @@ class BaseAstVisitor : public RecursiveASTVisitor { if (CanIgnoreCurrentASTNode()) return true; // In this case, we *know* we're responsible for destruction as well. - InstantiateImplicitMethods(expr->getConstructor()->getParent()); CXXConstructorDecl* ctor_decl = expr->getConstructor(); CXXDestructorDecl* dtor_decl = const_cast(GetSiblingDestructorFor(expr)); @@ -924,6 +845,12 @@ class BaseAstVisitor : public RecursiveASTVisitor { return true; } + /// Return whether this visitor should recurse into implicit + /// code, e.g., implicit constructors and destructors. + bool shouldVisitImplicitCode() const { + return true; + } + protected: CompilerInstance* compiler() { return compiler_; } @@ -1046,15 +973,7 @@ class AstFlattenerVisitor : public BaseAstVisitor { CHECK_(seen_nodes_.empty() && "Nodes should be clear before GetNodesBelow"); NodeSet* node_set = &nodeset_decl_cache_[decl]; if (node_set->empty()) { - if (decl->isImplicit()) { - // TODO: For now, it is only working for functions. Check if it could - // make sense for other implicit decls too (e.g. BuiltinTemplateDecl) - if (FunctionDecl* func = DynCastFrom(decl)) { - TraverseImplicitDeclHelper(func); - } - } else { - TraverseDecl(decl); - } + TraverseDecl(decl); swap(*node_set, seen_nodes_); // move the seen_nodes_ into the cache } return *node_set; // returns the cache entry @@ -1240,13 +1159,19 @@ class IwyuBaseAstVisitor : public BaseAstVisitor { using Base::PrintableCurrentLoc; using Base::current_ast_node; + enum class IgnoreKind { + ForUse, + ForExpansion, + }; + //------------------------------------------------------------ // Pure virtual methods that a subclass must implement. // Returns true if we are not interested in iwyu information for the // given type, where the type is *not* the current AST node. // TODO(csilvers): check we're calling this consistent with its API. - virtual bool CanIgnoreType(const Type* type) const = 0; + virtual bool CanIgnoreType(const Type* type, + IgnoreKind = IgnoreKind::ForUse) const = 0; // Returns true if we are not interested in doing an iwyu check on // the given decl, where the decl is *not* the current AST node. @@ -1647,7 +1572,7 @@ class IwyuBaseAstVisitor : public BaseAstVisitor { // Sometimes a shadow decl comes between us and the 'real' decl. if (const UsingShadowDecl* shadow_decl = DynCastFrom(used_decl)) target_decl = shadow_decl->getTargetDecl(); - + // Map private decls like __normal_iterator to their public counterpart. target_decl = MapPrivateDeclToPublicDecl(target_decl); if (CanIgnoreDecl(target_decl)) @@ -1675,7 +1600,7 @@ class IwyuBaseAstVisitor : public BaseAstVisitor { // instead? We can call it "Use what you use". :-) // TODO(csilvers): check for using statements and namespace aliases too. if (const UsingDecl* using_decl - = GetUsingDeclarationOf(used_decl, + = GetUsingDeclarationOf(used_decl, GetDeclContext(current_ast_node()))) { preprocessor_info().FileInfoFor(used_in)->ReportUsingDeclUse( used_loc, using_decl, use_flags, "(for using decl)"); @@ -1734,7 +1659,7 @@ class IwyuBaseAstVisitor : public BaseAstVisitor { // If we're a use that depends on a using declaration, make sure // we #include the file with the using declaration. if (const UsingDecl* using_decl - = GetUsingDeclarationOf(used_decl, + = GetUsingDeclarationOf(used_decl, GetDeclContext(current_ast_node()))) { preprocessor_info().FileInfoFor(used_in)->ReportUsingDeclUse( used_loc, using_decl, ComputeUseFlags(current_ast_node()), @@ -1799,6 +1724,17 @@ class IwyuBaseAstVisitor : public BaseAstVisitor { return true; } + bool VisitEnumDecl(clang::EnumDecl* decl) { + if (CanIgnoreCurrentASTNode()) + return true; + + clang::QualType integer_type = decl->getIntegerType(); + if (const clang::Type* type = integer_type.getTypePtrOrNull()) { + ReportTypeUse(CurrentLoc(), type); + } + return Base::VisitEnumDecl(decl); + } + // If you say 'typedef Foo Bar', C++ says you just need to // forward-declare Foo. But iwyu would rather you fully define Foo, // so all users of Bar don't have to. We make two exceptions: @@ -2223,6 +2159,29 @@ class IwyuBaseAstVisitor : public BaseAstVisitor { return true; } + bool VisitTypeTraitExpr(clang::TypeTraitExpr* expr) { + if (CanIgnoreCurrentASTNode()) + return true; + + // We assume that all type traits with >= 2 arguments require + // full type information even for pointer types. For example, + // this is the case for `__is_convertible_to` trait. + if (expr == nullptr || expr->getNumArgs() < 2) + return true; + + for (const clang::TypeSourceInfo* arg : expr->getArgs()) { + clang::QualType qual_type = arg->getType(); + const Type* type = qual_type.getTypePtr(); + const Type* deref_type = RemovePointersAndReferencesAsWritten(type); + + if (!CanIgnoreType(deref_type)) { + ReportTypeUse(CurrentLoc(), deref_type); + } + } + + return true; + } + // Mark that we need the full type info for the thing we're taking // sizeof of. Sometimes this is double-counting: for // sizeof(some_type), RecursiveASTVisitor will visit some_type and @@ -2233,6 +2192,8 @@ class IwyuBaseAstVisitor : public BaseAstVisitor { bool VisitUnaryExprOrTypeTraitExpr(clang::UnaryExprOrTypeTraitExpr* expr) { if (CanIgnoreCurrentASTNode()) return true; + current_ast_node()->set_in_forward_declare_context(false); + // Calling sizeof on a reference-to-X is the same as calling it on X. // If sizeof() takes a type, this is easy to check. If sizeof() // takes an expr, it's hard to tell -- GetTypeOf(expr) 'sees through' @@ -2539,8 +2500,7 @@ class IwyuBaseAstVisitor : public BaseAstVisitor { return Base::VisitType(type); } - bool VisitTemplateSpecializationType( - clang::TemplateSpecializationType* type) { + bool VisitTemplateSpecializationType(TemplateSpecializationType* type) { if (CanIgnoreCurrentASTNode() || CanIgnoreType(type)) return true; @@ -2565,9 +2525,7 @@ class IwyuBaseAstVisitor : public BaseAstVisitor { // If we're in an nns (e.g. the Foo in Foo::bar), we're never // forward-declarable, even if we're part of a pointer type, or in // a template argument, or whatever. - ASTNode* ast_node = current_ast_node(); - ast_node->set_in_forward_declare_context(false); - + current_ast_node()->set_in_forward_declare_context(false); return true; } @@ -2585,7 +2543,6 @@ class IwyuBaseAstVisitor : public BaseAstVisitor { if (!IsDefaultTemplateTemplateArg(ast_node)) { ast_node->set_in_forward_declare_context(true); - return; } } @@ -2643,9 +2600,7 @@ class IwyuBaseAstVisitor : public BaseAstVisitor { // return false; // Read past elaborations like 'class' keyword or namespaces. - while (ast_node->ParentIsA()) { - ast_node = ast_node->parent(); - } + ast_node = MostElaboratedAncestor(ast_node); // Now there are two options: either we have a type or we have a declaration // involving a type. @@ -2859,10 +2814,22 @@ class InstantiatedTemplateVisitor string GetSymbolAnnotation() const override { return " in tpl"; } - bool CanIgnoreType(const Type* type) const override { - if (!IsTypeInteresting(type) || !IsKnownTemplateParam(type)) + bool CanIgnoreType(const Type* type, IgnoreKind ignore_kind = + IgnoreKind::ForUse) const override { + if (!IsTypeInteresting(type)) return true; + switch (ignore_kind) { + case IgnoreKind::ForUse: + if (!IsKnownTemplateParam(type)) + return true; + break; + case IgnoreKind::ForExpansion: + if (!InvolvesKnownTemplateParam(type)) + return true; + break; + } + // If we're a default template argument, we should ignore the type // if the template author intend-to-provide it, but otherwise we // should not ignore it -- the caller is responsible for the type. @@ -2879,7 +2846,6 @@ class InstantiatedTemplateVisitor return IsDefaultTemplateParameter(type) && IsProvidedByTemplate(type); } - bool IsTypeInteresting(const Type* type) const { // We only care about types that would have been dependent in the // uninstantiated template: that is, SubstTemplateTypeParmType types @@ -2896,6 +2862,11 @@ class InstantiatedTemplateVisitor return ContainsKey(resugar_map_, type); } + bool InvolvesKnownTemplateParam(const Type* type) const { + return InvolvesTypeForWhich( + type, [&](const Type* type) { return IsKnownTemplateParam(type); }); + } + // We ignore function calls in nodes_to_ignore_, which were already // handled by the template-as-written, and function names that we // are not responsible for because the template code is (for @@ -2973,7 +2944,7 @@ class InstantiatedTemplateVisitor } bool TraverseTemplateSpecializationTypeHelper( - const clang::TemplateSpecializationType* type) { + const TemplateSpecializationType* type) { if (CanIgnoreCurrentASTNode()) return true; // Skip the template traversal if this occurrence of the template name is @@ -2999,21 +2970,21 @@ class InstantiatedTemplateVisitor return TraverseDataAndTypeMembersOfClassHelper(type); } - bool TraverseTemplateSpecializationType( - clang::TemplateSpecializationType* type) { + bool TraverseTemplateSpecializationType(TemplateSpecializationType* type) { if (!Base::TraverseTemplateSpecializationType(type)) return false; return TraverseTemplateSpecializationTypeHelper(type); } bool TraverseTemplateSpecializationTypeLoc( - clang::TemplateSpecializationTypeLoc typeloc) { + TemplateSpecializationTypeLoc typeloc) { if (!Base::TraverseTemplateSpecializationTypeLoc(typeloc)) return false; return TraverseTemplateSpecializationTypeHelper(typeloc.getTypePtr()); } bool TraverseSubstTemplateTypeParmTypeHelper( const clang::SubstTemplateTypeParmType* type) { - if (CanIgnoreCurrentASTNode() || CanIgnoreType(type)) + if (CanIgnoreCurrentASTNode() || + CanIgnoreType(type, IgnoreKind::ForExpansion)) return true; const Type* actual_type = ResugarType(type); @@ -3038,21 +3009,9 @@ class InstantiatedTemplateVisitor return TraverseSubstTemplateTypeParmTypeHelper(typeloc.getTypePtr()); } - // These do the actual work of finding the types to return. Our - // task is made easier since (at least in theory), every time we - // instantiate a template type, the instantiation has type - // SubstTemplateTypeParmTypeLoc in the AST tree. - bool VisitSubstTemplateTypeParmType(clang::SubstTemplateTypeParmType* type) { - if (CanIgnoreCurrentASTNode() || CanIgnoreType(type)) - return true; - - // Figure out how this type was actually written. clang always - // canonicalizes SubstTemplateTypeParmType, losing typedef info, etc. - const Type* actual_type = ResugarType(type); - CHECK_(actual_type && "If !CanIgnoreType(), we should be resugar-able"); - - // TODO(csilvers): whenever we report a type use here, we want to - // do an iwyu check on this type (to see if sub-types are used). + // Check whether a use of a template parameter is a full use. + bool IsTemplateTypeParmUseFullUse(const Type* type) { + const ASTNode* node = MostElaboratedAncestor(current_ast_node()); // If we're a nested-name-specifier class (the Foo in Foo::bar), // we need our full type info no matter what the context (even if @@ -3060,9 +3019,8 @@ class InstantiatedTemplateVisitor // TODO(csilvers): consider encoding this logic via // in_forward_declare_context. I think this will require changing // in_forward_declare_context to yes/no/maybe. - if (current_ast_node()->ParentIsA()) { - ReportTypeUse(CurrentLoc(), actual_type); - return Base::VisitSubstTemplateTypeParmType(type); + if (node->ParentIsA()) { + return true; } // If we're inside a typedef, we don't need our full type info -- @@ -3078,45 +3036,140 @@ class InstantiatedTemplateVisitor // to require it as well. TODO(csilvers): this doesn't really // make any sense. Who figures out we need the full type if // you do 'Foo::value_type m;'? - for (const ASTNode* ast_node = current_ast_node(); - ast_node != caller_ast_node_; ast_node = ast_node->parent()) { - if (ast_node->IsA()) - return Base::VisitSubstTemplateTypeParmType(type); + for (const ASTNode* ast_node = node; ast_node != caller_ast_node_; + ast_node = ast_node->parent()) { + if (ast_node->IsA()) { + return false; + } + if (ast_node->IsA()) { + // If we hit a template specialization node before the typedef then we + // probably still need a full-use, so stop looking. + break; + } } // sizeof(a reference type) is the same as sizeof(underlying type). // We have to handle that specially here, or else we'll say the // reference is forward-declarable, below. - if (current_ast_node()->ParentIsA() && - isa(actual_type)) { - const ReferenceType* actual_reftype = cast(actual_type); - ReportTypeUse(CurrentLoc(), - actual_reftype->getPointeeTypeAsWritten().getTypePtr()); - return Base::VisitSubstTemplateTypeParmType(type); + if (node->ParentIsA() && + isa(type)) { + return true; } // If we're used in a forward-declare context (MyFunc() { T* t; }), // or are ourselves a pointer type (MyFunc()), // we don't need to do anything: we're fine being forward-declared. - if (current_ast_node()->in_forward_declare_context()) - return Base::VisitSubstTemplateTypeParmType(type); + if (node->in_forward_declare_context()) + return false; - if (current_ast_node()->ParentIsA() || - current_ast_node()->ParentIsA() || - IsPointerOrReferenceAsWritten(actual_type)) - return Base::VisitSubstTemplateTypeParmType(type); + if (node->ParentIsA() || + node->ParentIsA() || + IsPointerOrReferenceAsWritten(type)) + return false; - // We attribute all uses in an instantiated template to the - // template's caller. - ReportTypeUse(caller_loc(), actual_type); + return true; + } + + // This helper is called on every use of a template argument type in an + // instantiated template. Its goal is to determine whether that use should + // constitute a full-use by the template caller, and perform other necessary + // bookkeeping. + void AnalyzeTemplateTypeParmUse(const Type* type) { + const ASTNode* node = MostElaboratedAncestor(current_ast_node()); + + // If the immediate parent node is a typedef, then register the new type as + // a new name for the template argument. + if (const TypedefNameDecl* typedef_decl = + node->GetParentAs()) { + const Type* typedef_type = typedef_decl->getTypeForDecl(); + VERRS(6) << "Registering " << PrintableType(typedef_type) + << " as an alias for " << PrintableType(type) + << " in the context of this instantiation\n"; + template_argument_aliases_.emplace(typedef_type, type); + } + + // Figure out how this type was actually written. clang always + // canonicalizes SubstTemplateTypeParmType, losing typedef info, etc. + const Type* actual_type = ResugarType(type); + CHECK_(actual_type && + "Type passed to AnalyzeTemplateTypeParmUse should be resugar-able"); - // Also report all previous explicit instantiations (declarations and - // definitions) as uses of the caller's location. - ReportExplicitInstantiations(actual_type); + VERRS(6) << "AnalyzeTemplateTypeParmUse: type = " << PrintableType(type) + << ", actual_type = " << PrintableType(actual_type) << '\n'; + + if (!IsTemplateTypeParmUseFullUse(actual_type)) { + // Non-full uses will already have been reported when they were used as + // template arguments, so nothing to do here. + return; + } + + if (isa(actual_type)) { + // If the argument type is a reference type, then we actually care about + // the referred-to type. + const ReferenceType* actual_reftype = cast(actual_type); + type = actual_reftype->getPointeeTypeAsWritten().getTypePtr(); + } + + // At this point we know we are looking at a full-use of type. However, + // there are still two cases. If this is a template param that was written + // by the user, then we report a use of it. However, it might also be a + // parameter of some implementation detail template which just happens top + // involve the user's template parameter somehow. In this case, we need to + // recursively explore the instantiation of *that* template to see if the + // user's type is full-used therein. + + if (IsKnownTemplateParam(type)) { + // We attribute all uses in an instantiated template to the + // template's caller. + ReportTypeUse(caller_loc(), type); + + // Also report all previous explicit instantiations (declarations and + // definitions) as uses of the caller's location. + ReportExplicitInstantiations(type); + } else { + const Decl* decl = TypeToDeclAsWritten(type); + if (const auto* cts_decl = + dyn_cast(decl)) { + if (ContainsKey(traversed_decls_, decl)) + return; // avoid recursion & repetition + traversed_decls_.insert(decl); + + VERRS(6) + << "Recursively traversing " << PrintableDecl(cts_decl) + << " which was full-used and involves a known template param\n"; + TraverseDecl(const_cast(cts_decl)); + } + } + } + + // Our task is made easier since (at least in theory), every time we + // instantiate a template type, the instantiation has type + // SubstTemplateTypeParmTypeLoc in the AST tree. + bool VisitSubstTemplateTypeParmType(clang::SubstTemplateTypeParmType* type) { + if (CanIgnoreCurrentASTNode() || + CanIgnoreType(type, IgnoreKind::ForExpansion)) + return true; + + AnalyzeTemplateTypeParmUse(type); return Base::VisitSubstTemplateTypeParmType(type); } + bool VisitTypedefType(clang::TypedefType* type) { + if (CanIgnoreCurrentASTNode()) + return true; + + // Typedefs of template arguments require special handling to ensure that + // we record full-uses of those arguments where appropriate. Those + // typedefs are stored in the template_argument_aliases_ map. + if (const Type* template_arg_type = + GetOrDefault(template_argument_aliases_, type, nullptr)) { + AnalyzeTemplateTypeParmUse(template_arg_type); + } + + return Base::VisitTypedefType(type); + } + bool VisitTemplateSpecializationType(TemplateSpecializationType* type) { if (CanIgnoreCurrentASTNode()) return true; @@ -3177,6 +3230,7 @@ class InstantiatedTemplateVisitor void Clear() { caller_ast_node_ = nullptr; resugar_map_.clear(); + template_argument_aliases_.clear(); traversed_decls_.clear(); nodes_to_ignore_.clear(); cache_storers_.clear(); @@ -3284,15 +3338,9 @@ class InstantiatedTemplateVisitor nodes_to_ignore_.AddAll(nodeset_getter.GetNodesBelow(daw)); } - // We need to iterate over the function. We do so even if it's - // an implicit function. - if (fn_decl->isImplicit()) { - if (!TraverseImplicitDeclHelper(const_cast(fn_decl))) - return false; - } else { - if (!TraverseDecl(const_cast(fn_decl))) - return false; - } + // We need to iterate over the function. + if (!TraverseDecl(const_cast(fn_decl))) + return false; // If we're a constructor, we also need to construct the entire class, // even typedefs that aren't used at construct time. Try compiling @@ -3350,8 +3398,12 @@ class InstantiatedTemplateVisitor if (class_decl == nullptr) { // If the template specialization decl is not sugar for a class, we // expect it to be another kind of template decl, like a built-in. - CHECK_(llvm::isa(named_decl)) - << "TemplateSpecializationType has no decl of type TemplateDecl?"; + // Also in some rare cases named_decl can be a record decl (e.g. when + // using the built-in __type_pack_element). + CHECK_(llvm::isa(named_decl) || + llvm::isa(named_decl)) + << "TemplateSpecializationType has no decl of type TemplateDecl or " + "RecordDecl?"; return true; } @@ -3502,6 +3554,12 @@ class InstantiatedTemplateVisitor // template-caller may or may not be responsible for. map resugar_map_; + // When we see a full-use of a template argument we need to assign that full + // use to the template-caller. Sometimes those uses are hidden behind + // type aliases (typedefs). This maps those aliases to the underlying + // template arguments. + map template_argument_aliases_; + // Used to avoid recursion in the *Helper() methods. set traversed_decls_; @@ -3563,7 +3621,7 @@ class IwyuAstConsumer string GetSymbolAnnotation() const override { return ""; } // We are interested in all types for iwyu checking. - bool CanIgnoreType(const Type* type) const override { + bool CanIgnoreType(const Type* type, IgnoreKind) const override { return type == nullptr; } @@ -3704,7 +3762,19 @@ class IwyuAstConsumer // though, because that will drag in every overload even if we're // only using one. Instead, we keep track of the using decl and // mark it as touched when something actually uses it. - preprocessor_info().FileInfoFor(CurrentFileEntry())->AddUsingDecl(decl); + IwyuFileInfo* file_info = + preprocessor_info().FileInfoFor(CurrentFileEntry()); + if (file_info) { + file_info->AddUsingDecl(decl); + } else { + // For using declarations in a PCH, the preprocessor won't have any + // location information. As far as we know, that's the only time the + // file-info will be null, so assert that we have a PCH on the + // command-line. + const string& pch_include = + compiler()->getInvocation().getPreprocessorOpts().ImplicitPCHInclude; + CHECK_(!pch_include.empty()); + } if (CanIgnoreCurrentASTNode()) return true; @@ -3714,6 +3784,10 @@ class IwyuAstConsumer bool VisitTagDecl(clang::TagDecl* decl) { if (CanIgnoreCurrentASTNode()) return true; + // Skip the injected class name. + if (decl->isImplicit()) + return Base::VisitTagDecl(decl); + if (IsForwardDecl(decl)) { // If we're a templated class, make sure we add the whole template. const NamedDecl* decl_to_fwd_declare = decl; @@ -3893,7 +3967,7 @@ class IwyuAstConsumer if (const TemplateSpecializationType* arg_tmpl = DynCastFrom(arg_type)) { // Special case: We are instantiating the type in the context of an // expression. Need to push the type to the AST stack explicitly. - ASTNode node(arg_tmpl, *GlobalSourceManager()); + ASTNode node(arg_tmpl); node.SetParent(current_ast_node()); instantiated_template_visitor_.ScanInstantiatedType( @@ -3956,8 +4030,7 @@ class IwyuAstConsumer // Like for CXXConstructExpr, etc., we sometimes need to instantiate // a class when looking at TemplateSpecializationType -- for instance, // when we need to access a class typedef: MyClass::value_type. - bool VisitTemplateSpecializationType( - clang::TemplateSpecializationType* type) { + bool VisitTemplateSpecializationType(TemplateSpecializationType* type) { if (CanIgnoreCurrentASTNode()) return true; // If we're not in a forward-declare context, use of a template diff --git a/iwyu_ast_util.cc b/iwyu_ast_util.cc index 2e2116a..1d37a17 100644 --- a/iwyu_ast_util.cc +++ b/iwyu_ast_util.cc @@ -18,14 +18,14 @@ #include "iwyu_globals.h" #include "iwyu_location_util.h" #include "iwyu_path_util.h" +#include "iwyu_port.h" // for CHECK_ #include "iwyu_stl_util.h" -#include "iwyu_string_util.h" #include "iwyu_verrs.h" -#include "port.h" // for CHECK_ #include "llvm/ADT/ArrayRef.h" #include "llvm/Support/Casting.h" #include "llvm/Support/raw_ostream.h" #include "clang/AST/ASTContext.h" +#include "clang/AST/ASTDumper.h" #include "clang/AST/CanonicalType.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclBase.h" @@ -47,6 +47,7 @@ namespace clang { class FileEntry; } // namespace clang +using clang::ASTDumper; using clang::BlockPointerType; using clang::CXXConstructExpr; using clang::CXXConstructorDecl; @@ -110,6 +111,7 @@ using clang::TemplateSpecializationKind; using clang::TemplateSpecializationType; using clang::TranslationUnitDecl; using clang::Type; +using clang::TypeAliasTemplateDecl; using clang::TypeDecl; using clang::TypeLoc; using clang::TypedefNameDecl; @@ -122,6 +124,7 @@ using llvm::ArrayRef; using llvm::PointerUnion; using llvm::cast; using llvm::dyn_cast; +using llvm::dyn_cast_or_null; using llvm::errs; using llvm::isa; using llvm::raw_string_ostream; @@ -183,13 +186,12 @@ SourceLocation ASTNode::GetLocation() const { // locations are in a different file, then we're uncertain of our // own location. Return an invalid location. if (retval.isValid()) { - FullSourceLoc full_loc(retval, source_manager_); + clang::SourceManager& sm = *GlobalSourceManager(); + FullSourceLoc full_loc(retval, sm); const FileEntry* spelling_file = - source_manager_.getFileEntryForID( - source_manager_.getFileID(full_loc.getSpellingLoc())); + sm.getFileEntryForID(sm.getFileID(full_loc.getSpellingLoc())); const FileEntry* instantiation_file = - source_manager_.getFileEntryForID( - source_manager_.getFileID(full_loc.getExpansionLoc())); + sm.getFileEntryForID(sm.getFileID(full_loc.getExpansionLoc())); if (spelling_file != instantiation_file) return SourceLocation(); } @@ -233,6 +235,14 @@ bool IsElaborationNode(const ASTNode* ast_node) { return elaborated_type && elaborated_type->getKeyword() != clang::ETK_None; } +const ASTNode* MostElaboratedAncestor(const ASTNode* ast_node) { + // Read past elaborations like 'class' keyword or namespaces. + while (ast_node->ParentIsA()) { + ast_node = ast_node->parent(); + } + return ast_node; +} + bool IsQualifiedNameNode(const ASTNode* ast_node) { if (ast_node == nullptr) return false; @@ -278,7 +288,7 @@ UseFlags ComputeUseFlags(const ASTNode* ast_node) { // Definitions of free functions are a little special, because they themselves // count as uses of all prior declarations (ideally we should probably just - // require one but it's hard so say which, so we pick all previously seen). + // require one but it's hard to say which, so we pick all previously seen). // Later IWYU analysis phases do some canonicalization that isn't // necessary/valid for this case, so mark it up for later. if (const auto* fd = ast_node->GetAs()) { @@ -441,12 +451,14 @@ string PrintableDecl(const Decl* decl, bool terse/*=true*/) { string PrintableStmt(const Stmt* stmt) { std::string buffer; raw_string_ostream ostream(buffer); - stmt->dump(ostream, *GlobalSourceManager()); + ASTDumper dumper(ostream, /*ShowColors=*/false); + dumper.Visit(stmt); return ostream.str(); } void PrintStmt(const Stmt* stmt) { - stmt->dump(*GlobalSourceManager()); // This prints to errs(). + ASTDumper dumper(llvm::errs(), /*ShowColors=*/false); + dumper.Visit(stmt); } string PrintableType(const Type* type) { @@ -596,14 +608,14 @@ bool HasImplicitConversionCtor(const CXXRecordDecl* cxx_class) { } // C++ [class.virtual]p8: -// If the return type of D::f differs from the return type of B::f, the +// If the return type of D::f differs from the return type of B::f, the // class type in the return type of D::f shall be complete at the point of // declaration of D::f or shall be the class type D. bool HasCovariantReturnType(const CXXMethodDecl* method_decl) { QualType derived_return_type = method_decl->getReturnType(); for (CXXMethodDecl::method_iterator - it = method_decl->begin_overridden_methods(); + it = method_decl->begin_overridden_methods(); it != method_decl->end_overridden_methods(); ++it) { // There are further constraints on covariant return types as such // (e.g. parents must be related, derived override must have return type @@ -752,17 +764,38 @@ GetTplTypeResugarMapForFunctionExplicitTplArgs( // possible. This was originally designed for use with function argument // expressions, and so might not work in a more general context. static const Type* GetSugaredTypeOf(const Expr* expr) { - // First, try to find an ImplicitCastExpr under the expr, and let that provide - // the type. This has a higher probability of yielding a sugared type. - for (const Stmt* child_expr : expr->children()) { - if (const auto* cast_expr = dyn_cast(child_expr)) { - return cast_expr->getType().getTypePtr(); + // Search the expression subtree for better sugar; stop as soon as a type + // different from expr's type is found. + struct Visitor : public RecursiveASTVisitor { + Visitor(QualType origtype) : sugared(origtype.getLocalUnqualifiedType()) { + } + + bool VisitDeclRefExpr(DeclRefExpr* e) { + return !CollectSugar(e); } - } - // If we didn't find a type via ImplicitCastExpr, just return the type of the - // expr itself. - return GetTypeOf(expr); + bool VisitImplicitCastExpr(ImplicitCastExpr* e) { + return !CollectSugar(e->getSubExpr()); + } + + bool CollectSugar(const Expr* e) { + QualType exprtype = e->getType().getLocalUnqualifiedType(); + if (!exprtype.isNull() && exprtype != sugared) { + sugared = exprtype; + return true; + } + + return false; + } + + QualType sugared; + }; + + // Default to the expr's type. + Visitor v(expr->getType()); + v.TraverseStmt(const_cast(expr)); + + return v.sugared.getTypePtr(); } map GetTplTypeResugarMapForFunction( @@ -915,29 +948,6 @@ const NamedDecl* GetDefinitionAsWritten(const NamedDecl* decl) { return decl; } -bool IsDefaultNewOrDelete(const FunctionDecl* decl, - const string& decl_loc_as_quoted_include) { - // Clang will report as the location of the default new and - // delete operators if is included. Otherwise, it reports the - // (fake) file "". - if (decl_loc_as_quoted_include != "" && - !IsBuiltinFile(GetFileEntry(decl))) - return false; - - const string decl_name = decl->getNameAsString(); - if (!StartsWith(decl_name, "operator new") && - !StartsWith(decl_name, "operator delete")) - return false; - - // Placement-new/delete has 2 args, second is void*. The only other - // 2-arg overloads of new/delete in take a const nothrow_t&. - if (decl->getNumParams() == 2 && - !decl->getParamDecl(1)->getType().isConstQualified()) - return false; - - return true; -} - bool IsFriendDecl(const Decl* decl) { // For 'template<...> friend class T', the decl will just be 'class T'. // We need to go 'up' a level to check friendship in the right place. @@ -953,8 +963,18 @@ bool IsExplicitInstantiation(const clang::Decl* decl) { kind == clang::TSK_ExplicitInstantiationDefinition; } +bool IsInInlineNamespace(const Decl* decl) { + const DeclContext* dc = decl->getDeclContext(); + for (; dc; dc = dc->getParent()) { + if (dc->isInlineNamespace()) + return true; + } + + return false; +} + bool IsForwardDecl(const NamedDecl* decl) { - if (const auto* record_decl = dyn_cast(decl)) { + if (const auto* record_decl = dyn_cast(decl)) { return (!record_decl->getName().empty() && !record_decl->isCompleteDefinition() && @@ -1139,6 +1159,26 @@ const Type* RemoveSubstTemplateTypeParm(const Type* type) { return type; } +bool InvolvesTypeForWhich(const Type* type, + std::function pred) { + type = RemoveSubstTemplateTypeParm(type); + if (pred(type)) + return true; + const Decl* decl = TypeToDeclAsWritten(type); + if (const auto* cts_decl = + dyn_cast_or_null(decl)) { + const TemplateArgumentList& tpl_args = cts_decl->getTemplateArgs(); + for (const TemplateArgument& tpl_arg : tpl_args.asArray()) { + if (const Type* arg_type = GetTemplateArgAsType(tpl_arg)) { + if (InvolvesTypeForWhich(arg_type, pred)) { + return true; + } + } + } + } + return false; +} + bool IsPointerOrReferenceAsWritten(const Type* type) { type = RemoveElaboration(type); return isa(type) || isa(type); @@ -1176,7 +1216,7 @@ const Type* RemovePointersAndReferences(const Type* type) { return type; } -const NamedDecl* TypeToDeclAsWritten(const Type* type) { +static const NamedDecl* TypeToDeclImpl(const Type* type, bool as_written) { // Get past all the 'class' and 'struct' prefixes, and namespaces. type = RemoveElaboration(type); @@ -1191,20 +1231,29 @@ const NamedDecl* TypeToDeclAsWritten(const Type* type) { // to keep typedefs as typedefs, so we do the record check last. // We use getAs<> when we can -- unfortunately, it only exists // for a few types so far. + const TemplateSpecializationType* template_spec_type = DynCastFrom(type); + const TemplateDecl* template_decl = + template_spec_type + ? template_spec_type->getTemplateName().getAsTemplateDecl() + : nullptr; + if (const TypedefType* typedef_type = DynCastFrom(type)) { return typedef_type->getDecl(); } else if (const InjectedClassNameType* icn_type = type->getAs()) { return icn_type->getDecl(); + } else if (as_written && template_decl && + isa(template_decl)) { + // A template type alias + return template_decl; } else if (const RecordType* record_type = type->getAs()) { return record_type->getDecl(); } else if (const TagType* tag_type = DynCastFrom(type)) { return tag_type->getDecl(); // probably just enums - } else if (const TemplateSpecializationType* template_spec_type - = DynCastFrom(type)) { + } else if (template_decl) { // A non-concrete template class, such as 'Myclass' - return template_spec_type->getTemplateName().getAsTemplateDecl(); + return template_decl; } else if (const FunctionType* function_type = DynCastFrom(type)) { // TODO(csilvers): is it possible to map from fn type to fn decl? (void)function_type; @@ -1214,6 +1263,14 @@ const NamedDecl* TypeToDeclAsWritten(const Type* type) { } } +const NamedDecl* TypeToDeclAsWritten(const Type* type) { + return TypeToDeclImpl(type, /*as_written=*/true); +} + +const NamedDecl* TypeToDeclForContent(const Type* type) { + return TypeToDeclImpl(type, /*as_written=*/false); +} + const Type* RemoveReferenceAsWritten(const Type* type) { if (const LValueReferenceType* ref_type = DynCastFrom(type)) return ref_type->getPointeeType().getTypePtr(); @@ -1249,13 +1306,20 @@ GetTplTypeResugarMapForClassNoComponentTypes(const clang::Type* type) { if (!tpl_spec_type) return retval; - // Get the list of template args that apply to the decls. + // Pull the template arguments out of the specialization type. If this is + // a ClassTemplateSpecializationDecl specifically, we want to + // get the arguments therefrom to correctly handle default arguments. + const TemplateArgument* tpl_args = tpl_spec_type->getArgs(); + unsigned num_args = tpl_spec_type->getNumArgs(); + const NamedDecl* decl = TypeToDeclAsWritten(tpl_spec_type); - const ClassTemplateSpecializationDecl* tpl_decl = DynCastFrom(decl); - if (!tpl_decl) // probably because tpl_spec_type is a dependent type - return retval; - const TemplateArgumentList& tpl_args - = tpl_decl->getTemplateInstantiationArgs(); + const auto* cls_tpl_decl = dyn_cast(decl); + if (cls_tpl_decl) { + const TemplateArgumentList& tpl_arg_list = + cls_tpl_decl->getTemplateInstantiationArgs(); + tpl_args = tpl_arg_list.data(); + num_args = tpl_arg_list.size(); + } // TemplateSpecializationType only includes explicitly specified // types in its args list, so we start with that. Note that an @@ -1271,12 +1335,13 @@ GetTplTypeResugarMapForClassNoComponentTypes(const clang::Type* type) { // (the latter are all desugared). If there's a match, update // the mapping. for (const Type* type : arg_components) { - for (unsigned i = 0; i < tpl_args.size(); ++i) { + for (unsigned i = 0; i < num_args; ++i) { if (const Type* arg_type = GetTemplateArgAsType(tpl_args[i])) { if (GetCanonicalType(type) == arg_type) { retval[arg_type] = type; VERRS(6) << "Adding a template-class type of interest: " - << PrintableType(type) << "\n"; + << PrintableType(arg_type) << " -> " << PrintableType(type) + << "\n"; explicit_args.insert(i); } } @@ -1285,7 +1350,7 @@ GetTplTypeResugarMapForClassNoComponentTypes(const clang::Type* type) { } // Now take a look at the args that were not filled explicitly. - for (unsigned i = 0; i < tpl_args.size(); ++i) { + for (unsigned i = 0; i < num_args; ++i) { if (ContainsKey(explicit_args, i)) continue; if (const Type* arg_type = GetTemplateArgAsType(tpl_args[i])) { diff --git a/iwyu_ast_util.h b/iwyu_ast_util.h index ac8707c..18ddf2d 100644 --- a/iwyu_ast_util.h +++ b/iwyu_ast_util.h @@ -16,8 +16,8 @@ #include // for set #include // for string +#include "iwyu_port.h" // for CHECK_ #include "iwyu_use_flags.h" -#include "port.h" // for CHECK_ #include "llvm/Support/Casting.h" #include "clang/AST/DeclBase.h" #include "clang/AST/NestedNameSpecifier.h" @@ -40,7 +40,6 @@ class ClassTemplateDecl; class Expr; class FunctionDecl; class NamedDecl; -class SourceManager; class TagDecl; class TemplateDecl; class TemplateName; @@ -72,37 +71,33 @@ class ASTNode { public: // In each case, the caller owns the object, and must guarantee it // lives for at least as long as the ASTNode object does. - ASTNode(const clang::Decl* decl, const clang::SourceManager& sm) + ASTNode(const clang::Decl* decl) : kind_(kDeclKind), as_decl_(decl), - parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } - ASTNode(const clang::Stmt* stmt, const clang::SourceManager& sm) + parent_(nullptr), in_fwd_decl_context_(false) { } + ASTNode(const clang::Stmt* stmt) : kind_(kStmtKind), as_stmt_(stmt), - parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } - ASTNode(const clang::Type* type, const clang::SourceManager& sm) + parent_(nullptr), in_fwd_decl_context_(false) { } + ASTNode(const clang::Type* type) : kind_(kTypeKind), as_type_(type), - parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } - ASTNode(const clang::TypeLoc* typeloc, const clang::SourceManager& sm) + parent_(nullptr), in_fwd_decl_context_(false) { } + ASTNode(const clang::TypeLoc* typeloc) : kind_(kTypelocKind), as_typeloc_(typeloc), - parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } - ASTNode(const clang::NestedNameSpecifier* nns, const clang::SourceManager& sm) + parent_(nullptr), in_fwd_decl_context_(false) { } + ASTNode(const clang::NestedNameSpecifier* nns) : kind_(kNNSKind), as_nns_(nns), - parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } - ASTNode(const clang::NestedNameSpecifierLoc* nnsloc, - const clang::SourceManager& sm) + parent_(nullptr), in_fwd_decl_context_(false) { } + ASTNode(const clang::NestedNameSpecifierLoc* nnsloc) : kind_(kNNSLocKind), as_nnsloc_(nnsloc), - parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } - ASTNode(const clang::TemplateName* template_name, - const clang::SourceManager& sm) + parent_(nullptr), in_fwd_decl_context_(false) { } + ASTNode(const clang::TemplateName* template_name) : kind_(kTemplateNameKind), as_template_name_(template_name), - parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } - ASTNode(const clang::TemplateArgument* template_arg, - const clang::SourceManager& sm) + parent_(nullptr), in_fwd_decl_context_(false) { } + ASTNode(const clang::TemplateArgument* template_arg) : kind_(kTemplateArgumentKind), as_template_arg_(template_arg), - parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } - ASTNode(const clang::TemplateArgumentLoc* template_argloc, - const clang::SourceManager& sm) + parent_(nullptr), in_fwd_decl_context_(false) { } + ASTNode(const clang::TemplateArgumentLoc* template_argloc) : kind_(kTemplateArgumentLocKind), as_template_argloc_(template_argloc), - parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } + parent_(nullptr), in_fwd_decl_context_(false) { } // A 'forward-declare' context means some parent of us can be // forward-declared, which means we can be too. e.g. in @@ -327,7 +322,6 @@ class ASTNode { }; const ASTNode* parent_; bool in_fwd_decl_context_; - const clang::SourceManager& source_manager_; }; // --- Helper classes for ASTNode. @@ -376,6 +370,11 @@ class CurrentASTNodeUpdater { // uses ElaboratedType for namespaces ('ns::Foo myvar'). bool IsElaborationNode(const ASTNode* ast_node); +// Walk up to parents of the given node so long as each parent is an +// elaboration node (in the sense of IsElaborationNode). +// Can expand from a node representing 'X' to e.g. 'struct X' or 'mylib::X'. +const ASTNode* MostElaboratedAncestor(const ASTNode* ast_node); + // See if a given ast_node is a qualified name part of an ElaboratedType // node (e.g. 'class ns::Foo x', 'class ::Global x' or 'class Outer::Inner x'.) bool IsQualifiedNameNode(const ASTNode* ast_node); @@ -584,12 +583,6 @@ const clang::NamedDecl* GetInstantiatedFromDecl( // the original input. const clang::NamedDecl* GetDefinitionAsWritten(const clang::NamedDecl* decl); -// True if this decl is for default (not placement-new) -// new/delete/new[]/delete[] from . The second argument -// is the quoted form of the file the decl comes from, e.g. ''. -bool IsDefaultNewOrDelete(const clang::FunctionDecl* decl, - const string& decl_loc_as_quoted_include); - // Returns true if this decl is part of a friend decl. bool IsFriendDecl(const clang::Decl* decl); @@ -597,6 +590,9 @@ bool IsFriendDecl(const clang::Decl* decl); // or definition. bool IsExplicitInstantiation(const clang::Decl* decl); +// Returns true if this decl is nested inside an inline namespace. +bool IsInInlineNamespace(const clang::Decl* decl); + // Returns true if a named decl looks like a forward-declaration of a // class (rather than a definition, a friend declaration, or an 'in // place' declaration like 'struct Foo' in 'void MyFunc(struct Foo*);' @@ -697,6 +693,11 @@ bool IsClassType(const clang::Type* type); // However, vector is *not* converted to vector. const clang::Type* RemoveSubstTemplateTypeParm(const clang::Type* type); +// Returns true if any type involved (recursively examining template +// arguments) satisfies the given predicate. +bool InvolvesTypeForWhich(const clang::Type* type, + std::function pred); + // Returns true if type is a pointer type (pointer or reference, // looking through elaborations like 'class Foo*' (vs 'Foo*'), // but *not* following typedefs (which is why we can't just use @@ -741,6 +742,16 @@ const clang::Type* RemovePointersAndReferences(const clang::Type* type); // this function returns nullptr. const clang::NamedDecl* TypeToDeclAsWritten(const clang::Type* type); +// This is similar to TypeToDeclAsWritten, but in this case we are less +// interested in how the type was written; we want the Decl which we can +// explore the contents of, for example to determine which of its template +// arguments are used in a manner that constitutes a full use. +// +// The difference arises particularly for type aliases, where +// TypeToDeclAsWritten returns the Decl for the alias, whereas +// TypeToDeclForContent returns the underlying aliased Decl. +const clang::NamedDecl* TypeToDeclForContent(const clang::Type* type); + // Returns true if it's possible to implicitly convert a value of a // different type to 'type' via an implicit constructor. bool HasImplicitConversionConstructor(const clang::Type* type); diff --git a/iwyu_cache.h b/iwyu_cache.h index 4d696c2..2efe2f3 100644 --- a/iwyu_cache.h +++ b/iwyu_cache.h @@ -19,8 +19,8 @@ #include // for set #include // for pair +#include "iwyu_port.h" // for CHECK_ #include "iwyu_stl_util.h" -#include "port.h" // for CHECK_ namespace clang { class NamedDecl; diff --git a/iwyu_driver.cc b/iwyu_driver.cc index eaeba46..42fea35 100644 --- a/iwyu_driver.cc +++ b/iwyu_driver.cc @@ -79,7 +79,7 @@ std::string GetExecutablePath(const char *Argv0) { } const char *SaveStringInSet(std::set &SavedStrings, StringRef S) { - return SavedStrings.insert(S).first->c_str(); + return SavedStrings.insert(S.str()).first->c_str(); } void ExpandArgsFromBuf(const char *Arg, @@ -205,11 +205,8 @@ CompilerInstance* CreateCompilerInstance(int argc, const char **argv) { // Initialize a compiler invocation object from the clang (-cc1) arguments. const ArgStringList &cc_arguments = command.getArguments(); - const char** args_start = const_cast(cc_arguments.data()); - const char** args_end = args_start + cc_arguments.size(); std::shared_ptr invocation(new CompilerInvocation); - CompilerInvocation::CreateFromArgs(*invocation, - args_start, args_end, diagnostics); + CompilerInvocation::CreateFromArgs(*invocation, cc_arguments, diagnostics); invocation->getFrontendOpts().DisableFree = false; // Use libc++ headers bundled with Xcode.app on macOS. diff --git a/iwyu_getopt.cc b/iwyu_getopt.cc index d8fb391..77323d1 100644 --- a/iwyu_getopt.cc +++ b/iwyu_getopt.cc @@ -5,10 +5,10 @@ // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // +//===----------------------------------------------------------------------===// + // This code is used with permission from Kim Gräsman. The original is // maintained with tests at: https://github.com/kimgr/getopt_port -// -//===----------------------------------------------------------------------===// #include "iwyu_getopt.h" diff --git a/iwyu_globals.cc b/iwyu_globals.cc index a971ad2..2699896 100644 --- a/iwyu_globals.cc +++ b/iwyu_globals.cc @@ -23,11 +23,11 @@ #include "iwyu_lexer_utils.h" #include "iwyu_location_util.h" #include "iwyu_path_util.h" +#include "iwyu_port.h" // for CHECK_, etc #include "iwyu_stl_util.h" #include "iwyu_string_util.h" #include "iwyu_verrs.h" #include "iwyu_version.h" -#include "port.h" // for CHECK_, etc #include "llvm/Support/raw_ostream.h" #include "clang/AST/PrettyPrinter.h" #include "clang/Basic/FileManager.h" @@ -166,6 +166,8 @@ CommandlineFlags::CommandlineFlags() no_fwd_decls(false), quoted_includes_first(false), cxx17ns(false) { + // Always keep Qt .moc includes; its moc compiler does its own IWYU analysis. + keep.emplace("*.moc"); } int CommandlineFlags::ParseArgv(int argc, char** argv) { @@ -291,7 +293,7 @@ static vector ComputeHeaderSearchPaths( for (auto it = header_search->system_dir_begin(); it != header_search->system_dir_end(); ++it) { if (const DirectoryEntry* entry = it->getDir()) { - const string path = NormalizeDirPath(MakeAbsolutePath(entry->getName())); + const string path = NormalizeDirPath(MakeAbsolutePath(entry->getName().str())); search_path_map[path] = HeaderSearchPath::kSystemPath; } } @@ -301,7 +303,7 @@ static vector ComputeHeaderSearchPaths( // search_dir_begin()/end() includes both system and user paths. // If it's a system path, it's already in the map, so everything // new is a user path. The insert only 'takes' for new entries. - const string path = NormalizeDirPath(MakeAbsolutePath(entry->getName())); + const string path = NormalizeDirPath(MakeAbsolutePath(entry->getName().str())); search_path_map.insert(make_pair(path, HeaderSearchPath::kUserPath)); } } diff --git a/iwyu_globals.h b/iwyu_globals.h index af40256..242cdf6 100644 --- a/iwyu_globals.h +++ b/iwyu_globals.h @@ -99,7 +99,7 @@ struct CommandlineFlags { bool pch_in_code; // Treat the first seen include as a PCH. No short option. bool no_comments; // Disable 'why' comments. No short option. bool no_fwd_decls; // Disable forward declarations. - bool quoted_includes_first; // Place quoted includes first in sort order. + bool quoted_includes_first; // Place quoted includes first in sort order. bool cxx17ns; // -C: C++17 nested namespace syntax }; diff --git a/iwyu_include_picker.cc b/iwyu_include_picker.cc index 145fd0c..76f1de7 100644 --- a/iwyu_include_picker.cc +++ b/iwyu_include_picker.cc @@ -16,7 +16,6 @@ // not hash_map: it's not as portable and needs hash. #include // for map, map<>::mapped_type, etc #include -#include #include // for string, basic_string, etc #include // for error_code #include // for pair, make_pair @@ -24,10 +23,10 @@ #include "iwyu_location_util.h" #include "iwyu_path_util.h" +#include "iwyu_port.h" #include "iwyu_stl_util.h" #include "iwyu_string_util.h" #include "iwyu_verrs.h" -#include "port.h" // for CHECK_ #include "llvm/ADT/StringRef.h" #include "llvm/Support/Casting.h" @@ -37,7 +36,6 @@ #include "llvm/Support/Regex.h" #include "llvm/Support/SourceMgr.h" #include "llvm/Support/YAMLParser.h" -#include "llvm/Support/raw_ostream.h" #include "clang/Basic/FileManager.h" using std::find; @@ -50,7 +48,6 @@ using std::vector; using llvm::MemoryBuffer; using llvm::SourceMgr; -using llvm::errs; using llvm::yaml::KeyValueNode; using llvm::yaml::MappingNode; using llvm::yaml::Node; @@ -137,6 +134,7 @@ const IncludeMapEntry libc_symbol_map[] = { { "intptr_t", kPrivate, "", kPublic }, { "key_t", kPrivate, "", kPublic }, { "key_t", kPrivate, "", kPublic }, + { "max_align_t", kPrivate, "", kPublic }, { "mode_t", kPrivate, "", kPublic }, { "mode_t", kPrivate, "", kPublic }, { "mode_t", kPrivate, "", kPublic }, @@ -157,6 +155,7 @@ const IncludeMapEntry libc_symbol_map[] = { { "pid_t", kPrivate, "", kPublic }, { "pid_t", kPrivate, "", kPublic }, { "pid_t", kPrivate, "", kPublic }, + { "ptrdiff_t", kPrivate, "", kPublic }, { "sigset_t", kPrivate, "", kPublic }, { "sigset_t", kPrivate, "", kPublic }, { "sigset_t", kPrivate, "", kPublic }, @@ -185,6 +184,8 @@ const IncludeMapEntry libc_symbol_map[] = { { "uid_t", kPrivate, "", kPublic }, { "useconds_t", kPrivate, "", kPublic }, { "useconds_t", kPrivate, "", kPublic }, + { "wchar_t", kPrivate, "", kPublic }, + { "wchar_t", kPrivate, "", kPublic }, // glob.h seems to define size_t if necessary, but it should come from stddef. // It is unspecified if the cname headers provide ::size_t. // is the one header which defines NULL but not size_t. @@ -352,6 +353,7 @@ const IncludeMapEntry libc_include_map[] = { { "", kPrivate, "", kPrivate }, { "", kPrivate, "", kPrivate }, { "", kPrivate, "", kPublic }, + { "", kPrivate, "", kPublic }, { "", kPrivate, "", kPublic }, { "", kPrivate, "", kPublic }, { "", kPrivate, "", kPublic }, @@ -875,20 +877,22 @@ bool IsQuotedFilepathPattern(const string& str) { // Given a vector of nodes, augment each node with its children, as // defined by m: nodes[i] is replaced by nodes[i] + m[nodes[i]], // ignoring duplicates. The input vector is modified in place. -void ExpandOnce(const IncludePicker::IncludeMap& m, vector* nodes) { - vector nodes_and_children; +void ExpandOnce(const IncludePicker::IncludeMap& m, + vector* nodes) { + vector nodes_and_children; set seen_nodes_and_children; - for (const string& node : *nodes) { + for (const MappedInclude& node : *nodes) { // First insert the node itself, then all its kids. - if (!ContainsKey(seen_nodes_and_children, node)) { + if (!ContainsKey(seen_nodes_and_children, node.quoted_include)) { nodes_and_children.push_back(node); - seen_nodes_and_children.insert(node); + seen_nodes_and_children.insert(node.quoted_include); } - if (const vector* children = FindInMap(&m, node)) { - for (const string& child : *children) { - if (!ContainsKey(seen_nodes_and_children, child)) { + if (const vector* children = + FindInMap(&m, node.quoted_include)) { + for (const MappedInclude& child : *children) { + if (!ContainsKey(seen_nodes_and_children, child.quoted_include)) { nodes_and_children.push_back(child); - seen_nodes_and_children.insert(child); + seen_nodes_and_children.insert(child.quoted_include); } } } @@ -938,9 +942,10 @@ void MakeNodeTransitive(IncludePicker::IncludeMap* filename_map, // Keep track of node->second as we update it, to avoid duplicates. (*seen_nodes)[key] = kCalculating; - for (const string& child : node->second) { - node_stack->push_back(child); - MakeNodeTransitive(filename_map, seen_nodes, node_stack, child); + for (const MappedInclude& child : node->second) { + node_stack->push_back(child.quoted_include); + MakeNodeTransitive(filename_map, seen_nodes, node_stack, + child.quoted_include); node_stack->pop_back(); } (*seen_nodes)[key] = kDone; @@ -1034,6 +1039,22 @@ string FindFileInSearchPath(const vector& search_path, } // anonymous namespace +MappedInclude::MappedInclude(const string& q, const string& p) + : quoted_include(q) + , path(p) +{ + CHECK_(IsQuotedInclude(quoted_include)) << + "Must be quoted include, was: " << quoted_include; +} + +bool MappedInclude::HasAbsoluteQuotedInclude() const { + if (!StartsWith(quoted_include, "\"") || quoted_include.size() < 2) { + return false; + } + string path(quoted_include.begin() + 1, quoted_include.end() - 1); + return IsAbsolutePath(path); +} + IncludePicker::IncludePicker(bool no_default_mappings) : has_called_finalize_added_include_lines_(false) { if (!no_default_mappings) { @@ -1056,17 +1077,17 @@ void IncludePicker::AddDefaultMappings() { IWYU_ARRAYSIZE(stdlib_cpp_public_headers)); } -void IncludePicker::MarkVisibility(const string& quoted_filepath_pattern, +void IncludePicker::MarkVisibility(VisibilityMap* map, + const string& key, IncludeVisibility visibility) { CHECK_(!has_called_finalize_added_include_lines_ && "Can't mutate anymore"); // insert() leaves any old value alone, and only inserts if the key is new. - filepath_visibility_map_.insert( - make_pair(quoted_filepath_pattern, visibility)); - CHECK_(filepath_visibility_map_[quoted_filepath_pattern] == visibility) + map->insert(make_pair(key, visibility)); + CHECK_((*map)[key] == visibility) << " Same file seen with two different visibilities: " - << quoted_filepath_pattern - << " Old vis: " << filepath_visibility_map_[quoted_filepath_pattern] + << key + << " Old vis: " << (*map)[key] << " New vis: " << visibility; } @@ -1084,6 +1105,7 @@ void IncludePicker::AddDirectInclude(const string& includer_filepath, // to our map, but harmless. const string quoted_includer = ConvertToQuotedInclude(includer_filepath); const string quoted_includee = ConvertToQuotedInclude(includee_filepath); + MappedInclude mapped_includer(quoted_includer, includer_filepath); quoted_includes_to_quoted_includers_[quoted_includee].insert(quoted_includer); const pair key(includer_filepath, includee_filepath); @@ -1106,7 +1128,7 @@ void IncludePicker::AddDirectInclude(const string& includer_filepath, // the closing quote as part of the .*. AddFriendRegex(includee_filepath, quoted_includee.substr(0, internal_pos) + ".*"); - AddMapping(quoted_includee, quoted_includer); + AddMapping(quoted_includee, mapped_includer); } // Automatically mark as private, and map to . @@ -1115,45 +1137,45 @@ void IncludePicker::AddDirectInclude(const string& includer_filepath, string public_header = quoted_includee; StripPast(&public_header, "/"); // read past "asm-whatever/" public_header = " - AddMapping(quoted_includee, public_header); + AddMapping(quoted_includee, MappedInclude(public_header)); } } -void IncludePicker::AddMapping(const string& map_from, const string& map_to) { - VERRS(8) << "Adding mapping from " << map_from << " to " << map_to << "\n"; +void IncludePicker::AddMapping(const string& map_from, + const MappedInclude& map_to) { + VERRS(8) << "Adding mapping from " << map_from << " to " + << map_to.quoted_include << "\n"; CHECK_(!has_called_finalize_added_include_lines_ && "Can't mutate anymore"); CHECK_(IsQuotedFilepathPattern(map_from) && "All map keys must be quoted filepaths or @ followed by regex"); - CHECK_(IsQuotedInclude(map_to) && "All map values must be quoted includes"); filepath_include_map_[map_from].push_back(map_to); } void IncludePicker::AddIncludeMapping(const string& map_from, IncludeVisibility from_visibility, - const string& map_to, + const MappedInclude& map_to, IncludeVisibility to_visibility) { AddMapping(map_from, map_to); - MarkVisibility(map_from, from_visibility); - MarkVisibility(map_to, to_visibility); + MarkVisibility(&include_visibility_map_, map_from, from_visibility); + MarkVisibility(&include_visibility_map_, map_to.quoted_include, + to_visibility); } void IncludePicker::AddSymbolMapping(const string& map_from, - const string& map_to, + const MappedInclude& map_to, IncludeVisibility to_visibility) { - CHECK_(IsQuotedInclude(map_to) && "Map values must be quoted includes"); symbol_include_map_[map_from].push_back(map_to); - // Symbol-names are always marked as private (or GetPublicValues() - // will self-map them, below). - MarkVisibility(map_from, kPrivate); - MarkVisibility(map_to, to_visibility); + MarkVisibility(&include_visibility_map_, map_to.quoted_include, + to_visibility); } void IncludePicker::AddIncludeMappings(const IncludeMapEntry* entries, size_t count) { for (size_t i = 0; i < count; ++i) { const IncludeMapEntry& e = entries[i]; - AddIncludeMapping(e.map_from, e.from_visibility, e.map_to, e.to_visibility); + AddIncludeMapping(e.map_from, e.from_visibility, MappedInclude(e.map_to), + e.to_visibility); } } @@ -1161,14 +1183,14 @@ void IncludePicker::AddSymbolMappings(const IncludeMapEntry* entries, size_t count) { for (size_t i = 0; i < count; ++i) { const IncludeMapEntry& e = entries[i]; - AddSymbolMapping(e.map_from, e.map_to, e.to_visibility); + AddSymbolMapping(e.map_from, MappedInclude(e.map_to), e.to_visibility); } } void IncludePicker::AddPublicIncludes(const char** includes, size_t count) { for (size_t i = 0; i < count; ++i) { const char* include = includes[i]; - MarkVisibility(include, kPublic); + MarkVisibility(&include_visibility_map_, include, kPublic); } } @@ -1177,7 +1199,12 @@ void IncludePicker::MarkIncludeAsPrivate( CHECK_(!has_called_finalize_added_include_lines_ && "Can't mutate anymore"); CHECK_(IsQuotedFilepathPattern(quoted_filepath_pattern) && "MIAP takes a quoted filepath pattern"); - MarkVisibility(quoted_filepath_pattern, kPrivate); + MarkVisibility(&include_visibility_map_, quoted_filepath_pattern, kPrivate); +} + +void IncludePicker::MarkPathAsPrivate(const string& path) { + CHECK_(!has_called_finalize_added_include_lines_ && "Can't mutate anymore"); + MarkVisibility(&path_visibility_map_, path, kPrivate); } void IncludePicker::AddFriendRegex(const string& includee_filepath, @@ -1199,6 +1226,17 @@ vector ExtractKeysMarkedAsRegexes(const MapType& m) { return regex_keys; } +bool ContainsQuotedInclude( + const vector& mapped_includes, + const string& quoted_include) { + for (const MappedInclude& mapped : mapped_includes) { + if (mapped.quoted_include == quoted_include) { + return true; + } + } + return false; +} + } // anonymous namespace // Expands the regex keys in filepath_include_map_ and @@ -1220,12 +1258,13 @@ void IncludePicker::ExpandRegexes() { for (const auto& incmap : quoted_includes_to_quoted_includers_) { const string& hdr = incmap.first; for (const string& regex_key : filepath_include_map_regex_keys) { - const vector& map_to = filepath_include_map_[regex_key]; + const vector& map_to = filepath_include_map_[regex_key]; // Enclose the regex in ^(...)$ for full match. llvm::Regex regex(std::string("^(" + regex_key.substr(1) + ")$")); - if (regex.match(hdr, nullptr) && !ContainsValue(map_to, hdr)) { + if (regex.match(hdr, nullptr) && !ContainsQuotedInclude(map_to, hdr)) { Extend(&filepath_include_map_[hdr], filepath_include_map_[regex_key]); - MarkVisibility(hdr, filepath_visibility_map_[regex_key]); + MarkVisibility(&include_visibility_map_, hdr, + include_visibility_map_[regex_key]); } } for (const string& regex_key : friend_to_headers_map_regex_keys) { @@ -1267,19 +1306,17 @@ void IncludePicker::FinalizeAddedIncludes() { // before returning the vector. *Also*, if the key is public in // the map, we insert the key as the first of the returned values, // this is an implicit "self-map." -vector IncludePicker::GetPublicValues( +vector IncludePicker::GetPublicValues( const IncludePicker::IncludeMap& m, const string& key) const { CHECK_(!StartsWith(key, "@")); - vector retval; - const vector* values = FindInMap(&m, key); + vector retval; + const vector* values = FindInMap(&m, key); if (!values || values->empty()) return retval; - if (GetOrDefault(filepath_visibility_map_, key, kPublic) == kPublic) - retval.push_back(key); // we can map to ourself! - for (const string& value : *values) { - CHECK_(!StartsWith(value, "@")); - if (GetOrDefault(filepath_visibility_map_, value, kPublic) == kPublic) + for (const MappedInclude& value : *values) { + CHECK_(!StartsWith(value.quoted_include, "@")); + if (GetVisibility(value, kPublic) == kPublic) retval.push_back(value); } return retval; @@ -1294,21 +1331,70 @@ string IncludePicker::MaybeGetIncludeNameAsWritten( return value ? *value : ""; } -vector IncludePicker::GetCandidateHeadersForSymbol( +vector IncludePicker::BestQuotedIncludesForIncluder( + const vector& includes, + const string& including_filepath) const { + // Convert each MappedInclude to a quoted include, according to the + // following priorities: + // 1. If the file is already included, use whatever name it's already + // included via. This is better to use than ConvertToQuotedInclude + // because it avoids trouble when the same file is accessible via + // different include search-paths, or is accessed via a symlink. + // 2. If the quoted include in the MappedInclude object is an absolute path, + // that's unlikely to be what's wanted. Try to convert it to a relative + // include via ConvertToQuotedInclude. + // 3. Otherwise, use the quoted include present in the MappedInclude. + const string including_path = + MakeAbsolutePath(GetParentPath(including_filepath)); + vector retval; + for (const MappedInclude& mapped_include : includes) { + const string& quoted_include_as_written = + MaybeGetIncludeNameAsWritten(including_filepath, mapped_include.path); + if (!quoted_include_as_written.empty()) { + retval.push_back(quoted_include_as_written); + } else if (mapped_include.HasAbsoluteQuotedInclude() && + !mapped_include.path.empty()) { + retval.push_back(ConvertToQuotedInclude(mapped_include.path, + including_path)); + } else { + retval.push_back(mapped_include.quoted_include); + } + } + return retval; +} + +vector IncludePicker::GetCandidateHeadersForSymbol( const string& symbol) const { CHECK_(has_called_finalize_added_include_lines_ && "Must finalize includes"); return GetPublicValues(symbol_include_map_, symbol); } -vector IncludePicker::GetCandidateHeadersForFilepath( +vector IncludePicker::GetCandidateHeadersForSymbolUsedFrom( + const string& symbol, const string& including_filepath) const { + return BestQuotedIncludesForIncluder( + GetCandidateHeadersForSymbol(symbol), including_filepath); +} + +vector IncludePicker::GetCandidateHeadersForFilepath( const string& filepath, const string& including_filepath) const { CHECK_(has_called_finalize_added_include_lines_ && "Must finalize includes"); - const string quoted_header = ConvertToQuotedInclude( - filepath, MakeAbsolutePath(GetParentPath(including_filepath))); - vector retval = GetPublicValues(filepath_include_map_, quoted_header); - if (retval.empty()) { - // the filepath isn't in include_map, so just quote and return it. - retval.push_back(quoted_header); + string absolute_quoted_header = ConvertToQuotedInclude(filepath); + vector retval = + GetPublicValues(filepath_include_map_, absolute_quoted_header); + + // We also need to consider the header itself. Make that an option if it's + // public or there's no other option. + string quoted_header; + if (including_filepath.empty()) { + quoted_header = absolute_quoted_header; + } else { + quoted_header = ConvertToQuotedInclude( + filepath, MakeAbsolutePath(GetParentPath(including_filepath))); + } + MappedInclude default_header(quoted_header, filepath); + if (retval.empty() || GetVisibility(default_header, kPublic) == kPublic) { + // Insert at front so it's the preferred option + retval.insert(retval.begin(), default_header); } return retval; } @@ -1318,48 +1404,35 @@ vector IncludePicker::GetCandidateHeadersForFilepath( // GetCandidateHeadersForFilepath. vector IncludePicker::GetCandidateHeadersForFilepathIncludedFrom( const string& included_filepath, const string& including_filepath) const { - vector retval; + vector mapped_includes; // We pass the own files path to ConvertToQuotedInclude so the quoted include // for the case that there is no matching `-I` option is just the filename // (e.g. "foo.cpp") instead of the absolute file path. + const string including_path = + MakeAbsolutePath(GetParentPath(including_filepath)); const string quoted_includer = ConvertToQuotedInclude( - including_filepath, MakeAbsolutePath(GetParentPath(including_filepath))); + including_filepath, including_path); const string quoted_includee = ConvertToQuotedInclude( - included_filepath, MakeAbsolutePath(GetParentPath(including_filepath))); + included_filepath, including_path); const set* headers_with_includer_as_friend = FindInMap(&friend_to_headers_map_, quoted_includer); if (headers_with_includer_as_friend != nullptr && ContainsKey(*headers_with_includer_as_friend, included_filepath)) { - retval.push_back(quoted_includee); + mapped_includes.push_back( + MappedInclude(quoted_includee, including_filepath)); } else { - retval = + mapped_includes = GetCandidateHeadersForFilepath(included_filepath, including_filepath); - if (retval.size() == 1) { - const string& quoted_header = retval[0]; - if (GetVisibility(quoted_header) == kPrivate) { + if (mapped_includes.size() == 1) { + if (GetVisibility(mapped_includes[0]) == kPrivate) { VERRS(0) << "Warning: " << "No public header found to replace the private header " - << quoted_header << "\n"; + << included_filepath << "\n"; } } } - // We'll have called ConvertToQuotedInclude on members of retval, - // but sometimes we can do better -- if included_filepath is in - // retval, the iwyu-preprocessor may have stored the quoted-include - // as written in including_filepath. This is better to use than - // ConvertToQuotedInclude because it avoids trouble when the same - // file is accessible via different include search-paths, or is - // accessed via a symlink. - const string& quoted_include_as_written - = MaybeGetIncludeNameAsWritten(including_filepath, included_filepath); - if (!quoted_include_as_written.empty()) { - vector::iterator it = std::find(retval.begin(), retval.end(), - quoted_includee); - if (it != retval.end()) - *it = quoted_include_as_written; - } - return retval; + return BestQuotedIncludesForIncluder(mapped_includes, including_filepath); } bool IncludePicker::HasMapping(const string& map_from_filepath, @@ -1368,12 +1441,11 @@ bool IncludePicker::HasMapping(const string& map_from_filepath, const string quoted_from = ConvertToQuotedInclude(map_from_filepath); const string quoted_to = ConvertToQuotedInclude(map_to_filepath); // We can't use GetCandidateHeadersForFilepath since includer might be private - const vector* all_mappers = FindInMap(&filepath_include_map_, - quoted_from); + const vector* all_mappers = + FindInMap(&filepath_include_map_, quoted_from); if (all_mappers) { - for (const string& mapper : *all_mappers) { - if (mapper == quoted_to) - return true; + if (ContainsQuotedInclude(*all_mappers, quoted_to)) { + return true; } } return quoted_to == quoted_from; // indentity mapping, why not? @@ -1381,8 +1453,10 @@ bool IncludePicker::HasMapping(const string& map_from_filepath, bool IncludePicker::IsPublic(const clang::FileEntry* file) const { CHECK_(file && "Need existing FileEntry"); - const string quoted_file = ConvertToQuotedInclude(GetFilePath(file)); - return (GetVisibility(quoted_file) == kPublic); + const string path = GetFilePath(file); + const string quoted_file = ConvertToQuotedInclude(path); + const MappedInclude include(quoted_file, path); + return (GetVisibility(include) == kPublic); } // Parses a YAML/JSON file containing mapping directives of various types. @@ -1405,8 +1479,8 @@ void IncludePicker::AddMappingsFromFile(const string& filename, llvm::ErrorOr> bufferOrError = MemoryBuffer::getFile(absolute_path); if (std::error_code error = bufferOrError.getError()) { - errs() << "Cannot open mapping file '" << absolute_path << "': " - << error.message() << ".\n"; + VERRS(0) << "Cannot open mapping file '" << absolute_path + << "': " << error.message() << ".\n"; return; } @@ -1470,7 +1544,7 @@ void IncludePicker::AddMappingsFromFile(const string& filename, return; } - AddSymbolMapping(mapping[0], mapping[2], to_visibility); + AddSymbolMapping(mapping[0], MappedInclude(mapping[2]), to_visibility); } else if (directive == "include") { // Include mapping. vector mapping = GetSequenceValue(mapping_item_node.getValue()); @@ -1513,7 +1587,7 @@ void IncludePicker::AddMappingsFromFile(const string& filename, AddIncludeMapping(mapping[0], from_visibility, - mapping[2], + MappedInclude(mapping[2]), to_visibility); } else if (directive == "ref") { // Mapping ref. @@ -1526,7 +1600,7 @@ void IncludePicker::AddMappingsFromFile(const string& filename, // Add the path of the file we're currently processing // to the search path. Allows refs to be relative to referrer. - vector extended_search_path = + vector extended_search_path = ExtendMappingFileSearchPath(search_path, GetParentPath(absolute_path)); @@ -1552,9 +1626,13 @@ IncludeVisibility IncludePicker::ParseVisibility( } IncludeVisibility IncludePicker::GetVisibility( - const string& quoted_include) const { - return GetOrDefault( - filepath_visibility_map_, quoted_include, kUnusedVisibility); + const MappedInclude& include, IncludeVisibility default_value) const { + const IncludeVisibility* include_visibility = + FindInMap(&include_visibility_map_, include.quoted_include); + if (include_visibility) { + return *include_visibility; + } + return GetOrDefault(path_visibility_map_, include.path, default_value); } } // namespace include_what_you_use diff --git a/iwyu_include_picker.h b/iwyu_include_picker.h index 9e58c58..5a1f1f0 100644 --- a/iwyu_include_picker.h +++ b/iwyu_include_picker.h @@ -67,9 +67,29 @@ struct IncludeMapEntry; enum IncludeVisibility { kUnusedVisibility, kPublic, kPrivate }; +// When a symbol or file is mapped to an include, that include is represented +// by this struct. It always has a quoted_include and may also have a path +// (depending on its origin). +struct MappedInclude { + explicit MappedInclude(const string& quoted_include, + const string& path = {}); + + string quoted_include; + string path; + + bool HasAbsoluteQuotedInclude() const; +}; + class IncludePicker { public: - typedef map> IncludeMap; // map_from to + // The keys are either symbol names or quoted includes, and the values are + // lists of candidate public headers to include for symbol or quoted include. + typedef map> IncludeMap; + + // Used to track visibility as specified either in mapping files or via + // pragmas. The keys are quoted includes or paths. The values are the + // visibility of the respective files. + typedef map VisibilityMap; explicit IncludePicker(bool no_default_mappings); @@ -83,14 +103,19 @@ class IncludePicker { const string& quoted_include_as_written); // Add this to say "map_to re-exports everything in file map_from". - // Both map_to and map_from should be quoted includes. - void AddMapping(const string& map_from, const string& map_to); + // map_from should be a quoted include. + void AddMapping(const string& map_from, const MappedInclude& map_to); // Indicate that the given quoted include should be considered // a "private" include. If possible, we use the include-picker - // mappings to map such includes to public (not-private) includs. + // mappings to map such includes to public (not-private) includes. void MarkIncludeAsPrivate(const string& quoted_include); + // Indicate that the given path should be considered + // a "private" include. If possible, we use the include-picker + // mappings to map such includes to public (not-private) includes. + void MarkPathAsPrivate(const string& path); + // Add this to say that "any file whose name matches the // friend_regex is allowed to include includee_filepath". The regex // uses the POSIX Entended Regular Expression syntax and should @@ -111,17 +136,24 @@ class IncludePicker { // important (which is why we return a vector, not a set): all else // being equal, the first element of the vector is the "best" (or // most standard) header for the symbol. - vector GetCandidateHeadersForSymbol(const string& symbol) const; + vector GetCandidateHeadersForSymbol( + const string& symbol) const; + + // As above, but given a specific including header it is possible to convert + // mapped includes to quoted include strings (because we can for example know + // the correct relative path for ""-style includes). + vector GetCandidateHeadersForSymbolUsedFrom( + const string& symbol, const string& including_filepath) const; // Returns the set of all public header files that a given header // file -- specified as a full path -- would map to, as a set of - // quoted includes such as ''. If the include-picker has + // MappedIncludes. If the include-picker has // no mapping information for this file, the return vector has just // the input file (now include-quoted). Ordering is important // (which is why we return a vector, not a set): all else being // equal, the first element of the vector is the "best" (or most // standard) header for the input header. - vector GetCandidateHeadersForFilepath( + vector GetCandidateHeadersForFilepath( const string& filepath, const string& including_filepath = "") const; // This allows for special-casing of GetCandidateHeadersForFilepath @@ -132,6 +164,8 @@ class IncludePicker { // not when #included from "qux/quux.h". In the common case there's // no special-casing, and this falls back on // GetCandidateHeadersForFilepath(). + // Furthermore, knowing the including file allows use to convert each + // MappedInclude in the result to a simple string (quoted include). vector GetCandidateHeadersForFilepathIncludedFrom( const string& included_filepath, const string& including_filepath) const; @@ -160,14 +194,14 @@ class IncludePicker { // Adds a mapping from a one header to another, typically // from a private to a public quoted include. void AddIncludeMapping( - const string& map_from, IncludeVisibility from_visibility, - const string& map_to, IncludeVisibility to_visibility); + const string& map_from, IncludeVisibility from_visibility, + const MappedInclude& map_to, IncludeVisibility to_visibility); - // Adds a mapping from a a symbol to a quoted include. We use this to + // Adds a mapping from a a symbol to a quoted include. We use this to // maintain mappings of documented types, e.g. // For std::map<>, include . void AddSymbolMapping( - const string& map_from, const string& map_to, + const string& map_from, const MappedInclude& map_to, IncludeVisibility to_visibility); // Adds mappings from sized arrays of IncludeMapEntry. @@ -181,22 +215,25 @@ class IncludePicker { // seen by iwyu. void ExpandRegexes(); - // Adds an entry to filepath_visibility_map_, with error checking. - void MarkVisibility(const string& quoted_filepath_pattern, + // Adds an entry to the given VisibilityMap, with error checking. + void MarkVisibility(VisibilityMap* map, const string& key, IncludeVisibility visibility); // Parse visibility from a string. Returns kUnusedVisibility if // string is not recognized. IncludeVisibility ParseVisibility(const string& visibility) const; - // Return the visibility of a given quoted_include if known, else + // Return the visibility of a given mapped include if known, else // kUnusedVisibility. - IncludeVisibility GetVisibility(const string& quoted_include) const; + IncludeVisibility GetVisibility( + const MappedInclude&, + IncludeVisibility default_value = kUnusedVisibility) const; // For the given key, return the vector of values associated with // that key, or an empty vector if the key does not exist in the // map, filtering out private files. - vector GetPublicValues(const IncludeMap& m, const string& key) const; + vector GetPublicValues(const IncludeMap& m, + const string& key) const; // Given an includer-pathname and includee-pathname, return the // quoted-include of the includee, as written in the includer, or @@ -204,6 +241,11 @@ class IncludePicker { string MaybeGetIncludeNameAsWritten(const string& includer_filepath, const string& includee_filepath) const; + // Given a collection of MappedIncludes, and a path that might include them, + // choose the best quoted include form for each MappedInclude. + vector BestQuotedIncludesForIncluder( + const vector&, const string& including_filepath) const; + // From symbols to includes. IncludeMap symbol_include_map_; @@ -216,8 +258,15 @@ class IncludePicker { IncludeMap filepath_include_map_; // A map of all quoted-includes to whether they're public or private. - // Quoted-includes that are not present in this map are assumed public. - map filepath_visibility_map_; + // Files whose visibility cannot be determined by this map nor the one + // below are assumed public. + VisibilityMap include_visibility_map_; + + // A map of paths to whether they're public or private. + // Files whose visibility cannot be determined by this map nor the one + // above are assumed public. + // The include_visibility_map_ takes priority over this one. + VisibilityMap path_visibility_map_; // All the includes we've seen so far, to help with globbing and // other dynamic mapping. For each file, we list who #includes it. diff --git a/iwyu_lexer_utils.cc b/iwyu_lexer_utils.cc index 0475600..648c9da 100644 --- a/iwyu_lexer_utils.cc +++ b/iwyu_lexer_utils.cc @@ -9,10 +9,10 @@ #include "iwyu_lexer_utils.h" #include "iwyu_globals.h" +#include "iwyu_port.h" // for CHECK_ #include -#include "port.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManager.h" #include "clang/Lex/Token.h" @@ -70,7 +70,7 @@ SourceLocation GetLocationAfter( string GetIncludeNameAsWritten( SourceLocation include_loc, const CharacterDataGetterInterface& data_getter) { - const string data = GetSourceTextUntilEndOfLine(include_loc, data_getter); + const string data = GetSourceTextUntilEndOfLine(include_loc, data_getter).str(); if (data.empty()) return data; string::size_type endpos = string::npos; diff --git a/iwyu_location_util.h b/iwyu_location_util.h index 3892a42..6f8cf81 100644 --- a/iwyu_location_util.h +++ b/iwyu_location_util.h @@ -89,7 +89,7 @@ bool IsInScratchSpace(clang::SourceLocation loc); inline string GetFilePath(const clang::FileEntry* file) { return (IsBuiltinFile(file) ? "" : - NormalizeFilePath(file->getName())); + NormalizeFilePath(file->getName().str())); } //------------------------------------------------------------ diff --git a/iwyu_output.cc b/iwyu_output.cc index 7ad540d..e102ccb 100644 --- a/iwyu_output.cc +++ b/iwyu_output.cc @@ -54,6 +54,7 @@ using clang::SourceRange; using clang::TemplateDecl; using clang::UsingDecl; using llvm::cast; +using llvm::dyn_cast; using llvm::errs; using llvm::isa; using llvm::raw_string_ostream; @@ -167,7 +168,7 @@ string GetKindName(const clang::TagDecl* tag_decl) { if (const FakeNamedDecl* fake = FakeNamedDeclIfItIsOne(named_decl)) { return fake->kind_name(); } - return tag_decl->getKindName(); + return tag_decl->getKindName().str(); } string GetQualifiedNameAsString(const clang::NamedDecl* named_decl) { @@ -295,11 +296,13 @@ void OneUse::SetPublicHeaders() { // who we map to. CHECK_(suggested_header_.empty() && "Should not need a public header here"); const IncludePicker& picker = GlobalIncludePicker(); // short alias + const string use_path = GetFilePath(use_loc_); // If the symbol has a special mapping, use it, otherwise map its file. - public_headers_ = picker.GetCandidateHeadersForSymbol(symbol_name_); + public_headers_ = picker.GetCandidateHeadersForSymbolUsedFrom( + symbol_name_, use_path); if (public_headers_.empty()) public_headers_ = picker.GetCandidateHeadersForFilepathIncludedFrom( - decl_filepath_, GetFilePath(use_loc_)); + decl_filepath_, use_path); if (public_headers_.empty()) public_headers_.push_back(ConvertToQuotedInclude(decl_filepath_)); } @@ -346,20 +349,6 @@ string PrintablePtr(const void* ptr) { // `-- TagDecl (class, struct, union, enum) // `-- RecordDecl (class, struct, union) -// Determines if a NamedDecl has any parent namespace, which is anonymous. -bool HasAnonymousNamespace(const NamedDecl* decl) { - for (const DeclContext* ctx = decl->getDeclContext(); - ctx && isa(ctx); ctx = ctx->getParent()) { - if (const NamespaceDecl* ns = DynCastFrom(ctx)) { - if (ns->isAnonymousNamespace()) { - return true; - } - } - } - - return false; -} - // Given a NamedDecl that presents a (possibly template) record // (i.e. class, struct, or union) type declaration, and the print-out // of its (possible) template parameters and kind (e.g. "template @@ -378,7 +367,7 @@ string PrintForwardDeclare(const NamedDecl* decl, std::string fwd_decl = std::string(decl->getName()) + ";"; bool seen_namespace = false; // Anonymous namespaces are not using the more concise syntax. - bool concat_namespaces = cxx17ns && !HasAnonymousNamespace(decl); + bool concat_namespaces = cxx17ns && !decl->isInAnonymousNamespace(); for (const DeclContext* ctx = decl->getDeclContext(); ctx && isa(ctx); ctx = ctx->getParent()) { if (const RecordDecl* rec = DynCastFrom(ctx)) { @@ -446,16 +435,24 @@ string MungedForwardDeclareLineForTemplates(const TemplateDecl* decl) { raw_string_ostream ostream(line); decl->print(ostream); // calls DeclPrinter line = ostream.str(); - string::size_type endpos = line.length(); // Get rid of the superclasses, if any (this will nix the body too). line = Split(line, " :", 2)[0]; // Get rid of the template body, if any (true if no superclasses). line = Split(line, " {", 2)[0]; + + // Remove "final" specifier which isn't needed for forward + // declarations. + const char kFinalSpecifier[] = " final "; + string::size_type final_pos = line.find(kFinalSpecifier); + if (final_pos != string::npos) { + line.replace(final_pos, sizeof(kFinalSpecifier), " "); + } + // The template name is now the last word on the line. Replace it - // by its fully-qualified form. Apparently rfind's endpos - // argument is inclusive, so substract one to get past the end-space. - const string::size_type name = line.rfind(' ', endpos - 1); + // by its fully-qualified form. + const string::size_type name = line.rfind(' '); CHECK_(name != string::npos && "Unexpected printable template-type"); + return PrintForwardDeclare(decl, line.substr(0, name), GlobalFlags().cxx17ns); } @@ -587,8 +584,8 @@ void IwyuFileInfo::AddUsingDecl(const UsingDecl* using_decl) { int start_linenum = GetLineNumber(GetInstantiationLoc(decl_lines.getBegin())); int end_linenum = GetLineNumber(GetInstantiationLoc(decl_lines.getEnd())); VERRS(6) << "Found using-decl: " - << GetFilePath(file_) << ":" - << to_string(start_linenum) << "-" << to_string(end_linenum) << ": " + << GetFilePath(file_) << ":" + << to_string(start_linenum) << "-" << to_string(end_linenum) << ": " << internal::PrintablePtr(using_decl) << internal::GetQualifiedNameAsString(using_decl) << "\n"; } @@ -681,7 +678,7 @@ void IwyuFileInfo::ReportForwardDeclareUse(SourceLocation use_loc, void IwyuFileInfo::ReportUsingDeclUse(SourceLocation use_loc, const UsingDecl* using_decl, UseFlags flags, - const char* comment) { + const char* comment) { // If accessing a symbol through a using decl in the same file that contains // the using decl, we must mark the using decl as referenced. At the end of // traversing the AST, we check to see if a using decl is unreferenced and @@ -719,18 +716,34 @@ static void LogIncludeMapping(const string& reason, const OneUse& use) { namespace internal { -bool DeclCanBeForwardDeclared(const Decl* decl) { - // Class templates can always be forward-declared. - if (isa(decl)) - return true; +bool DeclCanBeForwardDeclared(const Decl* decl, string* reason) { + // Nothing inside an inline namespace can be forward-declared. + if (IsInInlineNamespace(decl)) { + *reason = "in inline namespace"; + return false; + } - // Other record decls can be forward-declared unless they denote a lambda - // expression; these have no type name to forward-declare. - if (const RecordDecl* record = DynCastFrom(decl)) { - return !record->isLambda(); + if (isa(decl)) { + // Class templates can always be forward-declared. + } else if (const auto* record = dyn_cast(decl)) { + // Record decls can be forward-declared unless they denote a lambda + // expression; these have no type name to forward-declare. + if (record->isLambda()) { + *reason = "is a lambda"; + return false; + } + } else { + // Other decl types are not forward-declarable. + *reason = "not a record or class template"; + return false; } - return false; + return true; +} + +bool DeclCanBeForwardDeclared(const Decl* decl) { + string reason; + return DeclCanBeForwardDeclared(decl, &reason); } // Helper to tell whether a forward-declare use is 'preceded' by a @@ -750,8 +763,8 @@ bool DeclIsVisibleToUseInSameFile(const Decl* decl, const OneUse& use) { // method. return (IsBeforeInSameFile(decl, use.use_loc()) || GetLocation(decl) == use.use_loc() || - (DeclsAreInSameClass(decl, use.decl()) && !decl->isOutOfLine() - && use.in_cxx_method_body())); + (DeclsAreInSameClass(decl, use.decl()) && !decl->isOutOfLine() && + (use.flags() & UF_InCxxMethodBody))); } // This makes a best-effort attempt to find the smallest set of @@ -1011,11 +1024,12 @@ void ProcessForwardDeclare(OneUse* use, if (use->ignore_use()) // we're already ignoring it return; - // (A1) If not a class or a templated class, recategorize as a full use. - if (!DeclCanBeForwardDeclared(use->decl())) { + // (A1) If not suitable for forward-declaration, recategorize as a full use. + string reason; + if (!DeclCanBeForwardDeclared(use->decl(), &reason)) { VERRS(6) << "Moving " << use->symbol_name() - << " from fwd-decl use to full use: not a class" - << " (" << use->PrintableUseLoc() << ")\n"; + << " from fwd-decl use to full use: " << reason << " (" + << use->PrintableUseLoc() << ")\n"; use->set_full_use(); return; } @@ -1105,13 +1119,29 @@ void ProcessForwardDeclare(OneUse* use, } } - // (A7) If --no_fwd_decls has been passed, recategorize as a full use unless - // the decl is in this file (in which case it must be a self-sufficient decl - // being used, so we can just let IWYU do its work). - if (!use->ignore_use() && - GlobalFlags().no_fwd_decls && - GetFileEntry(use->decl_loc()) != GetFileEntry(use->use_loc())) { - use->set_full_use(); + // (A7) If --no_fwd_decls has been passed, and a decl can be found in one of + // the headers, suggest that header, and recategorize as a full use. If we can + // only find a decl in this file, it must be a self-sufficent decl being used, + // so we can just let IWYU do its work, and there is no need to recategorize. + if (!use->ignore_use() && GlobalFlags().no_fwd_decls) { + bool promote_to_full_use = true; + for (const Decl* decl = use->decl(); decl != nullptr; + decl = decl->getPreviousDecl()) { + if (IsBeforeInSameFile(decl->getLocation(), use->use_loc())) { + promote_to_full_use = false; + } else if (IsBeforeInTranslationUnit(decl->getLocation(), + use->use_loc())) { + // TODO: Choose a redecl that is already provided by a desired include, so we + // don't keep another include that is not necessary. + use->reset_decl(cast(decl)); + promote_to_full_use = true; + break; + } + } + + if (promote_to_full_use) { + use->set_full_use(); + } } } @@ -1179,7 +1209,7 @@ void ProcessFullUse(OneUse* use, // All this is moot when FunctionDecls are being defined, all their redecls // are separately registered as uses so that a definition anchors all its // declarations. - if (!use->is_function_being_defined() && !is_builtin_function_with_mappings) { + if (!(use->flags() & UF_FunctionDfn) && !is_builtin_function_with_mappings) { set all_redecls; if (isa(use->decl()) || isa(use->decl())) all_redecls.insert(use->decl()); // for classes, just consider the dfn @@ -1212,10 +1242,14 @@ void ProcessFullUse(OneUse* use, return; } // Special case for operators new/delete: Only treated as built-in if they - // are the default, non-placement versions. + // are the default, non-placement versions. This is modelled in Clang as + // 'replaceable global allocation functions': the helper method returns true + // for anything but placement-new. Users of the 'std::nothrow' and + // 'std::align_val_t' overloads already need to spell these two symbols, so + // will be required for them without us doing any magic for operator new + // itself. if (const FunctionDecl* fn_decl = DynCastFrom(use->decl())) { - const string dfn_file = GetFilePath(fn_decl); - if (IsDefaultNewOrDelete(fn_decl, ConvertToQuotedInclude(dfn_file))) { + if (fn_decl->isReplaceableGlobalAllocationFunction()) { VERRS(6) << "Ignoring use of " << use->symbol_name() << " (" << use->PrintableUseLoc() << "): built-in new/delete\n"; use->set_ignore_use(); @@ -1241,13 +1275,14 @@ void ProcessFullUse(OneUse* use, // mapping to choose, and it's important we use the one that iwyu // will pick later). TODO(csilvers): figure out that case too. const IncludePicker& picker = GlobalIncludePicker(); - const vector& method_dfn_files = + const vector& method_dfn_files = picker.GetCandidateHeadersForFilepath(GetFilePath(decl_file_entry)); - const vector& parent_dfn_files = + const vector& parent_dfn_files = picker.GetCandidateHeadersForFilepath(GetFilePath(parent_file_entry)); bool same_file; if (method_dfn_files.size() == 1 && parent_dfn_files.size() == 1) { - same_file = (method_dfn_files[0] == parent_dfn_files[0]); + same_file = (method_dfn_files[0].quoted_include == + parent_dfn_files[0].quoted_include); } else { // Fall back on just checking the filenames: can't figure out public. same_file = (decl_file_entry == parent_file_entry); @@ -1358,14 +1393,10 @@ void CalculateIwyuForForwardDeclareUse( // If this record is defined in one of the desired_includes, mark that // fact. Also if it's defined in one of the actual_includes. - const NamedDecl* dfn = GetDefinitionForClass(use->decl()); - // If we are, ourselves, a template specialization, then the definition - // we use is not the definition of the specialization (that's us), but - // the definition of the template we're specializing. - if (spec_decl && dfn == spec_decl) - dfn = GetDefinitionForClass(spec_decl->getSpecializedTemplate()); bool dfn_is_in_desired_includes = false; bool dfn_is_in_actual_includes = false; + + const NamedDecl* dfn = GetDefinitionForClass(use->decl()); if (dfn) { vector headers = GlobalIncludePicker().GetCandidateHeadersForFilepathIncludedFrom( @@ -2066,7 +2097,8 @@ void IwyuFileInfo::HandlePreprocessingDone() { ERRSYM(file_) << "Mark " << quoted_file_ << " as public header for " << private_include << " because used macro is defined by includer.\n"; - MutableGlobalIncludePicker()->AddMapping(private_include, quoted_file_); + MutableGlobalIncludePicker()->AddMapping( + private_include, MappedInclude(quoted_file_, GetFilePath(file_))); MutableGlobalIncludePicker()->MarkIncludeAsPrivate(private_include); } } diff --git a/iwyu_output.h b/iwyu_output.h index 719f821..ac2c2bc 100644 --- a/iwyu_output.h +++ b/iwyu_output.h @@ -21,9 +21,9 @@ #include // for string, operator< #include // for vector +#include "iwyu_port.h" // for CHECK_ #include "iwyu_stl_util.h" #include "iwyu_use_flags.h" -#include "port.h" // for CHECK_ #include "clang/AST/Decl.h" #include "clang/Basic/SourceLocation.h" @@ -72,8 +72,7 @@ class OneUse { clang::SourceLocation use_loc() const { return use_loc_; } clang::SourceLocation decl_loc() const { return decl_loc_; } bool is_full_use() const { return use_kind_ == kFullUse; } - bool in_cxx_method_body() const { return (use_flags_ & UF_InCxxMethodBody); } - bool is_function_being_defined() const { return (use_flags_ & UF_FunctionDfn); } + UseFlags flags() const { return use_flags_; } const string& comment() const { return comment_; } bool ignore_use() const { return ignore_use_; } bool is_iwyu_violation() const { return is_iwyu_violation_; } @@ -256,7 +255,7 @@ class IwyuFileInfo { UseFlags flags, const char* comment); // Called whenever a NamedDecl is accessed through a UsingDecl. - // ie: using std::swap; swap(a, b); + // ie: using std::swap; swap(a, b); void ReportUsingDeclUse(clang::SourceLocation use_loc, const clang::UsingDecl* using_decl, UseFlags flags, const char* comment); diff --git a/iwyu_path_util.cc b/iwyu_path_util.cc index 5d37367..9987ea4 100644 --- a/iwyu_path_util.cc +++ b/iwyu_path_util.cc @@ -127,14 +127,14 @@ string GetCanonicalName(string file_path) { string NormalizeFilePath(const string& path) { llvm::SmallString<128> normalized(path); - llvm::sys::path::remove_dots(normalized); + llvm::sys::path::remove_dots(normalized, /*remove_dot_dot=*/true); #ifdef _WIN32 // Canonicalize directory separators (forward slashes considered canonical.) std::replace(normalized.begin(), normalized.end(), '\\', '/'); #endif - return normalized.str(); + return normalized.str().str(); } string NormalizeDirPath(const string& path) { @@ -154,14 +154,14 @@ string MakeAbsolutePath(const string& path) { std::error_code error = llvm::sys::fs::make_absolute(absolute_path); CHECK_(!error); - return absolute_path.str(); + return absolute_path.str().str(); } string MakeAbsolutePath(const string& base_path, const string& relative_path) { llvm::SmallString<128> absolute_path(base_path); llvm::sys::path::append(absolute_path, relative_path); - return absolute_path.str(); + return absolute_path.str().str(); } string GetParentPath(const string& path) { diff --git a/iwyu_port.h b/iwyu_port.h new file mode 100644 index 0000000..d890575 --- /dev/null +++ b/iwyu_port.h @@ -0,0 +1,88 @@ +//===--- iwyu_port.h - OS/cpu specific stuff for include-what-you-use -----===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// Source file for architecture-specific logic. + +#ifndef INCLUDE_WHAT_YOU_USE_PORT_H_ +#define INCLUDE_WHAT_YOU_USE_PORT_H_ + +#include // for abort +#include "llvm/Support/Compiler.h" +#include "llvm/Support/raw_ostream.h" + +// Count of statically allocated array. +#define IWYU_ARRAYSIZE(arr) sizeof(arr) / sizeof(*arr) + +namespace include_what_you_use { + +// Helper class that allows programmers to log extra information in CHECK_s. +class FatalMessageEmitter { + public: + FatalMessageEmitter(const char* file, int line, const char* message) { + stream() << file << ":" << line << ": Assertion failed: " << message; + } + LLVM_ATTRIBUTE_NORETURN ~FatalMessageEmitter() { + stream() << "\n"; + ::abort(); +#ifdef LLVM_BUILTIN_UNREACHABLE + // Windows systems and possibly others don't declare abort() to be noreturn, + // so use the unreachable builtin to avoid a Clang self-host warning. + LLVM_BUILTIN_UNREACHABLE; +#endif + } + llvm::raw_ostream& stream() { return llvm::errs(); } +}; + +// Helper class that allows an ostream to 'appear' as a void expression. +class OstreamVoidifier { + public: + // This has to be an operator with a precedence lower than << but + // higher than ?: + void operator&(llvm::raw_ostream&) {} +}; + +} // namespace include_what_you_use + +// Usage: CHECK_(condition) << extra << information; +// The file, line, condition and extra information will be printed to stderr, +// then the program will abort. +#define CHECK_(x) (x) ? (void)0 : \ + ::include_what_you_use::OstreamVoidifier() & \ + ::include_what_you_use::FatalMessageEmitter( \ + __FILE__, __LINE__, #x).stream() +// Instead of CHECK_(false && "message") use CHECK_UNREACHABLE_("message"). +#define CHECK_UNREACHABLE_(message) \ + ::include_what_you_use::OstreamVoidifier() & \ + ::include_what_you_use::FatalMessageEmitter( \ + __FILE__, __LINE__, message).stream() + +#if defined(_WIN32) + +#define NOMINMAX 1 // Prevent Windows headers from redefining min/max. +#include "Shlwapi.h" // for PathMatchSpecA + +// This undef is necessary to prevent conflicts between llvm +// and Windows headers. +// objbase.h has #define interface struct. +#undef interface + +inline bool GlobMatchesPath(const char *glob, const char *path) { + return PathMatchSpecA(path, glob); +} + +#else // #if defined(_WIN32) + +#include + +inline bool GlobMatchesPath(const char *glob, const char *path) { + return fnmatch(glob, path, 0) == 0; +} + +#endif // #if defined(_WIN32) + +#endif // INCLUDE_WHAT_YOU_USE_PORT_H_ diff --git a/iwyu_preprocessor.cc b/iwyu_preprocessor.cc index bacfa70..88b9314 100644 --- a/iwyu_preprocessor.cc +++ b/iwyu_preprocessor.cc @@ -23,10 +23,10 @@ #include "iwyu_location_util.h" #include "iwyu_output.h" #include "iwyu_path_util.h" +#include "iwyu_port.h" // for CHECK_ #include "iwyu_stl_util.h" #include "iwyu_string_util.h" #include "iwyu_verrs.h" -#include "port.h" // for CHECK_ // TODO(wan): remove this once the IWYU bug is fixed. // IWYU pragma: no_include "foo/bar/baz.h" #include "llvm/Support/raw_ostream.h" @@ -34,6 +34,7 @@ #include "clang/Lex/MacroInfo.h" using clang::FileEntry; +using clang::FileEntryRef; using clang::FileID; using clang::MacroDefinition; using clang::MacroDirective; @@ -228,7 +229,8 @@ void IwyuPreprocessorInfo::HandlePragmaComment(SourceRange comment_range) { const string quoted_this_file = ConvertToQuotedInclude(GetFilePath(begin_loc)); - MutableGlobalIncludePicker()->AddMapping(quoted_this_file, suggested); + MutableGlobalIncludePicker()->AddMapping(quoted_this_file, + MappedInclude(suggested)); MutableGlobalIncludePicker()->MarkIncludeAsPrivate(quoted_this_file); ERRSYM(this_file_entry) << "Adding private pragma-mapping: " << quoted_this_file << " -> " @@ -237,11 +239,10 @@ void IwyuPreprocessorInfo::HandlePragmaComment(SourceRange comment_range) { } if (MatchOneToken(tokens, "private", 1, begin_loc)) { - const string quoted_this_file - = ConvertToQuotedInclude(GetFilePath(begin_loc)); - MutableGlobalIncludePicker()->MarkIncludeAsPrivate(quoted_this_file); - ERRSYM(this_file_entry) << "Adding private include: " - << quoted_this_file << "\n"; + const string path_this_file = GetFilePath(begin_loc); + MutableGlobalIncludePicker()->MarkPathAsPrivate(path_this_file); + ERRSYM(this_file_entry) << "Adding private path: " + << path_this_file << "\n"; return; } @@ -312,7 +313,7 @@ void IwyuPreprocessorInfo::ProcessHeadernameDirectivesInFile( break; } const string filename = GetSourceTextUntilEndOfLine(current_loc, - DefaultDataGetter()); + DefaultDataGetter()).str(); // Use "" or <> based on where the file lives. string quoted_private_include; if (IsSystemIncludeFile(GetFilePath(current_loc))) @@ -331,7 +332,7 @@ void IwyuPreprocessorInfo::ProcessHeadernameDirectivesInFile( } string after_text = GetSourceTextUntilEndOfLine(current_loc, - DefaultDataGetter()); + DefaultDataGetter()).str(); const string::size_type close_brace_pos = after_text.find('}'); if (close_brace_pos == string::npos) { Warn(current_loc, "@headername directive missing a closing brace"); @@ -343,8 +344,8 @@ void IwyuPreprocessorInfo::ProcessHeadernameDirectivesInFile( for (string& public_include : public_includes) { StripWhiteSpace(&public_include); const string quoted_header_name = "<" + public_include + ">"; - MutableGlobalIncludePicker()->AddMapping(quoted_private_include, - quoted_header_name); + MutableGlobalIncludePicker()->AddMapping( + quoted_private_include, MappedInclude(quoted_header_name)); MutableGlobalIncludePicker()->MarkIncludeAsPrivate( quoted_private_include); ERRSYM(GetFileEntry(current_loc)) << "Adding @headername mapping: " @@ -409,13 +410,23 @@ void IwyuPreprocessorInfo::MaybeProtectInclude( LineHasText(includer_loc, "/* IWYU pragma: export") || HasOpenBeginExports(includer)) { protect_reason = "pragma_export"; - const string quoted_includer = - ConvertToQuotedInclude(GetFilePath(includer)); - MutableGlobalIncludePicker()->AddMapping(include_name_as_written, - quoted_includer); + const string includer_path = GetFilePath(includer); + const string quoted_includer = ConvertToQuotedInclude(includer_path); + MappedInclude map_to(quoted_includer, includer_path); + MutableGlobalIncludePicker()->AddMapping(include_name_as_written, map_to); ERRSYM(includer) << "Adding pragma-export mapping: " - << include_name_as_written << " -> " << quoted_includer - << "\n"; + << include_name_as_written << " -> " + << map_to.quoted_include << "\n"; + // Relative includes can be problematic as map keys, because they are + // context-dependent. Convert it to a context-free quoted include + // (which may contain the full path to the file), and add that too. + string map_from = ConvertToQuotedInclude(GetFilePath(includee)); + if (map_from != include_name_as_written) { + MutableGlobalIncludePicker()->AddMapping(map_from, map_to); + ERRSYM(includer) << "Adding pragma-export mapping: " + << map_from << " -> " << map_to.quoted_include + << "\n"; + } // We also always keep #includes of .c files: iwyu doesn't touch those. // TODO(csilvers): instead of IsHeaderFile, check if the file has @@ -521,6 +532,16 @@ void IwyuPreprocessorInfo::AddDirectInclude( ->AddAssociatedHeader(GetFromFileInfoMap(includee)); VERRS(4) << "Marked " << GetFilePath(includee) << " as associated header of " << GetFilePath(includer) << ".\n"; + + // All associated headers need to be included in IWYU analysis. + // We can only get here if IWYU is invoked with an absolute source path and + // its associated header is included by two different path names (e.g. + // "rel/path/assoc.h" and "assoc.h") in different files. + // + // TODO: This line cannot be covered with our current test framework; + // don't forget to add a test case if we build something better in the + // future. + AddGlobToReportIWYUViolationsFor(GetFilePath(includee)); } // Besides marking headers as "associated header" with heuristics, the user @@ -684,7 +705,7 @@ void IwyuPreprocessorInfo::FileChanged(SourceLocation loc, // Called when we see an #include, but decide we don't need to // actually read it because it's already been #included (and is // protected by a header guard). -void IwyuPreprocessorInfo::FileSkipped(const FileEntry& file, +void IwyuPreprocessorInfo::FileSkipped(const FileEntryRef& file, const Token &filename, SrcMgr::CharacteristicKind file_type) { CHECK_(include_filename_loc_.isValid() && @@ -695,11 +716,11 @@ void IwyuPreprocessorInfo::FileSkipped(const FileEntry& file, GetInstantiationLoc(filename.getLocation()); ERRSYM(GetFileEntry(include_loc)) << "[ (#include) ] " << include_name_as_written - << " (" << GetFilePath(&file) << ")\n"; + << " (" << GetFilePath(&file.getFileEntry()) << ")\n"; - AddDirectInclude(include_loc, &file, include_name_as_written); - if (ShouldReportIWYUViolationsFor(&file)) { - files_to_report_iwyu_violations_for_.insert(&file); + AddDirectInclude(include_loc, &file.getFileEntry(), include_name_as_written); + if (ShouldReportIWYUViolationsFor(&file.getFileEntry())) { + files_to_report_iwyu_violations_for_.insert(&file.getFileEntry()); } } @@ -847,12 +868,13 @@ void IwyuPreprocessorInfo::PopulateIntendsToProvideMap() { map> private_headers_behind; for (const auto& fileinfo : iwyu_file_info_map_) { const FileEntry* header = fileinfo.first; - const vector public_headers_for_header = + const vector public_headers_for_header = GlobalIncludePicker().GetCandidateHeadersForFilepath( GetFilePath(header)); - for (const string& pub : public_headers_for_header) { - if (const FileEntry* public_file - = GetOrDefault(include_to_fileentry_map_, pub, nullptr)) { + for (const MappedInclude& pub : public_headers_for_header) { + if (const FileEntry* public_file = + GetOrDefault(include_to_fileentry_map_, pub.quoted_include, + nullptr)) { CHECK_(ContainsKey(iwyu_file_info_map_, public_file)); if (public_file != header) // no credit for mapping to yourself :-) private_headers_behind[public_file].insert(header); diff --git a/iwyu_preprocessor.h b/iwyu_preprocessor.h index 76eabef..3f0bbf4 100644 --- a/iwyu_preprocessor.h +++ b/iwyu_preprocessor.h @@ -66,7 +66,7 @@ #include // for vector #include "iwyu_output.h" -#include "port.h" +#include "iwyu_port.h" // for CHECK_ #include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManager.h" @@ -204,7 +204,7 @@ class IwyuPreprocessorInfo : public clang::PPCallbacks, void FileChanged(clang::SourceLocation loc, FileChangeReason reason, clang::SrcMgr::CharacteristicKind file_type, clang::FileID exiting_from_id) override; - void FileSkipped(const clang::FileEntry& file, const clang::Token &filename, + void FileSkipped(const clang::FileEntryRef& file, const clang::Token &filename, clang::SrcMgr::CharacteristicKind file_type) override; // FileChanged is actually a multi-plexer for 4 different callbacks. void FileChanged_EnterFile(clang::SourceLocation file_beginning); diff --git a/iwyu_string_util.h b/iwyu_string_util.h index f1b1e5e..78c2dc7 100644 --- a/iwyu_string_util.h +++ b/iwyu_string_util.h @@ -18,7 +18,7 @@ #include #include -#include "port.h" +#include "iwyu_port.h" namespace include_what_you_use { diff --git a/iwyu_test_util.py b/iwyu_test_util.py index dfe37b6..26ebf38 100755 --- a/iwyu_test_util.py +++ b/iwyu_test_util.py @@ -1,13 +1,13 @@ #!/usr/bin/env python -##===--- iwyu_test_util.py - include-what-you-use test framework -----------===## +##===--- iwyu_test_util.py - include-what-you-use test framework ----------===## # # The LLVM Compiler Infrastructure # # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # -##===-----------------------------------------------------------------------===## +##===----------------------------------------------------------------------===## """Utilities for writing tests for IWYU. diff --git a/iwyu_tool.py b/iwyu_tool.py index 7b11156..a0768d6 100755 --- a/iwyu_tool.py +++ b/iwyu_tool.py @@ -1,4 +1,14 @@ #!/usr/bin/env python + +##===--- iwyu_tool.py -----------------------------------------------------===## +# +# The LLVM Compiler Infrastructure +# +# This file is distributed under the University of Illinois Open Source +# License. See LICENSE.TXT for details. +# +##===----------------------------------------------------------------------===## + """ Driver to consume a Clang compilation database and invoke IWYU. Example usage with CMake: @@ -257,6 +267,11 @@ class Process(object): return cls(process, outfile) +KNOWN_COMPILER_WRAPPERS=frozenset([ + "ccache" +]) + + class Invocation(object): """ Holds arguments of an IWYU invocation. """ def __init__(self, command, cwd): @@ -278,6 +293,10 @@ class Invocation(object): else: raise ValueError('Invalid compilation database entry: %s' % entry) + if command[0] in KNOWN_COMPILER_WRAPPERS: + # Remove the compiler wrapper from the command. + command = command[1:] + # Rewrite the compile command for IWYU compile_command, compile_args = command[0], command[1:] if is_msvc_driver(compile_command): @@ -290,24 +309,19 @@ class Invocation(object): def start(self, verbose): """ Run invocation and collect output. """ if verbose: - print('# %s' % self) + print('# %s' % self, file=sys.stderr) return Process.start(self) -def parse_compilation_db(compilation_db_path): - """ Parse JSON compilation database and return a canonicalized form. """ - if os.path.isdir(compilation_db_path): - compilation_db_path = os.path.join(compilation_db_path, - 'compile_commands.json') - - # Read compilation db from disk. - compilation_db_path = os.path.realpath(compilation_db_path) - with open(compilation_db_path, 'r') as fileobj: - compilation_db = json.load(fileobj) - - # Expand symlinks. +def fixup_compilation_db(compilation_db): + """ Canonicalize paths in JSON compilation database. """ for entry in compilation_db: + # Convert relative paths to absolute ones if possible, based on the entry's directory. + if 'directory' in entry and not os.path.isabs(entry['file']): + entry['file'] = os.path.join(entry['directory'], entry['file']) + + # Expand relative paths and symlinks entry['file'] = os.path.realpath(entry['file']) return compilation_db @@ -324,12 +338,13 @@ def slice_compilation_db(compilation_db, selection): new_db = [] for path in selection: if not os.path.exists(path): - print('WARNING: \'%s\' not found on disk.' % path) + print('warning: \'%s\' not found on disk.' % path, file=sys.stderr) continue found = [e for e in compilation_db if is_subpath_of(e['file'], path)] if not found: - print('WARNING: \'%s\' not found in compilation database.' % path) + print('warning: \'%s\' not found in compilation database.' % path, + file=sys.stderr) continue new_db.extend(found) @@ -365,12 +380,26 @@ def main(compilation_db_path, source_files, verbose, formatter, jobs, extra_args): """ Entry point. """ + if not IWYU_EXECUTABLE: + print('error: include-what-you-use executable not found', + file=sys.stderr) + return 1 + try: - compilation_db = parse_compilation_db(compilation_db_path) + if os.path.isdir(compilation_db_path): + compilation_db_path = os.path.join(compilation_db_path, + 'compile_commands.json') + + # Read compilation db from disk. + compilation_db_path = os.path.realpath(compilation_db_path) + with open(compilation_db_path, 'r') as fileobj: + compilation_db = json.load(fileobj) except IOError as why: - print('Failed to parse JSON compilation database: %s' % why) + print('error: failed to parse compilation database: %s' % why, + file=sys.stderr) return 1 + compilation_db = fixup_compilation_db(compilation_db) compilation_db = slice_compilation_db(compilation_db, source_files) # Transform compilation db entries into a list of IWYU invocations. diff --git a/iwyu_tool_test.py b/iwyu_tool_test.py index c9b3ddd..d524dac 100755 --- a/iwyu_tool_test.py +++ b/iwyu_tool_test.py @@ -1,6 +1,6 @@ #!/usr/bin/env python -##===-------------- iwyu_tool_test.py - test for iwyu_tool.py -------------===## +##===--- iwyu_tool_test.py - test for iwyu_tool.py ------------------------===## # # The LLVM Compiler Infrastructure # @@ -8,6 +8,7 @@ # License. See LICENSE.TXT for details. # ##===----------------------------------------------------------------------===## +import os import sys import time import random @@ -272,5 +273,56 @@ class BootstrapTests(unittest.TestCase): self.main.call_args['extra_args']) +class CompilationDBTests(unittest.TestCase): + def setUp(self): + self.cwd = os.path.realpath(os.getcwd()) + + def test_fixup_compilation_db(self): + """ Compilation database path canonicalization. """ + compilation_db = [ + { + "file": "Test.cpp" + } + ] + + canonical = iwyu_tool.fixup_compilation_db(compilation_db) + + # Check that file path is made absolute. + entry = canonical[0] + self.assertEqual(os.path.join(self.cwd, 'Test.cpp'), entry['file']) + + def test_fixup_from_entry_dir(self): + """ Compilation database abs path is based on an entry's directory. """ + + # Use a root dir from uuidgen so we don't risk hitting a real path. + compilation_db = [ + { + "directory": "/c057f113f69311e990bf54a05050d914/foobar", + "file": "Test.cpp" + } + ] + + canonical = iwyu_tool.fixup_compilation_db(compilation_db) + + # Check that the file path is relative to the directory entry, + # not to the current directory. + entry = canonical[0] + self.assertEqual('/c057f113f69311e990bf54a05050d914/foobar/Test.cpp', + entry['file']) + + def test_unwrap_compile_command(self): + """ Wrapping compile commands should be unwrapped. """ + compilation_db = { + 'directory': '/home/user/llvm/build', + "command": "ccache cc -c test.c" + } + + invocation = iwyu_tool.Invocation.from_compile_command(compilation_db, []) + + self.assertEqual( + invocation.command, + [iwyu_tool.IWYU_EXECUTABLE, '-c', 'test.c']) + + if __name__ == '__main__': unittest.main() diff --git a/iwyu_version.h b/iwyu_version.h index ea150da..3cfbb5d 100644 --- a/iwyu_version.h +++ b/iwyu_version.h @@ -10,6 +10,6 @@ #ifndef INCLUDE_WHAT_YOU_USE_IWYU_VERSION_H_ #define INCLUDE_WHAT_YOU_USE_IWYU_VERSION_H_ -#define IWYU_VERSION_STRING "0.12" +#define IWYU_VERSION_STRING "0.15" #endif // INCLUDE_WHAT_YOU_USE_IWYU_VERSION_H_ diff --git a/more_tests/iwyu_include_picker_test.cc b/more_tests/iwyu_include_picker_test.cc index be55316..8f2b72b 100644 --- a/more_tests/iwyu_include_picker_test.cc +++ b/more_tests/iwyu_include_picker_test.cc @@ -13,7 +13,6 @@ #include "iwyu_include_picker.h" #include -#include #include #include #include @@ -36,27 +35,21 @@ namespace include_what_you_use { namespace { -string IntToString(int i) { - char buf[64]; // big enough for any number - snprintf(buf, sizeof(buf), "%d", i); - return buf; -} - // Returns a string representing the first element where actual (a vector), // and expected (an array) differ, or "" if they're identical. template string VectorDiff(const string (&expected)[kCount], const vector& actual) { for (int i = 0; i < std::min(kCount, actual.size()); ++i) { if (expected[i] != actual[i]) { - return ("Differ at #" + IntToString(i) + ": expected=" + expected[i] + + return ("Differ at #" + std::to_string(i) + ": expected=" + expected[i] + ", actual=" + actual[i]); } } if (kCount < actual.size()) { - return ("Differ at #" + IntToString(kCount) + + return ("Differ at #" + std::to_string(kCount) + ": expected at EOF, actual=" + actual[kCount]); } else if (actual.size() < kCount) { - return ("Differ at #" + IntToString(kCount) + ": expected=" + + return ("Differ at #" + std::to_string(kCount) + ": expected=" + expected[actual.size()] + ", actual at EOF"); } else { return ""; diff --git a/port.h b/port.h deleted file mode 100644 index 4f87a26..0000000 --- a/port.h +++ /dev/null @@ -1,90 +0,0 @@ -//===--- port.h - OS/cpu specific stuff for include-what-you-use ----------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// Source file for architecture-specific logic. - -#ifndef INCLUDE_WHAT_YOU_USE_PORT_H_ -#define INCLUDE_WHAT_YOU_USE_PORT_H_ - -#include // for abort -#include -#include "llvm/Support/Compiler.h" - -// Count of statically allocated array. -#define IWYU_ARRAYSIZE(arr) sizeof(arr) / sizeof(*arr) - -namespace include_what_you_use { - -// Helper class that allows programmers to log extra information in CHECK_s. -class FatalMessageEmitter { - public: - FatalMessageEmitter(const char* file, int line, const char* message) { - stream() << file << ":" << line << ": Assertion failed: " << message; - } - LLVM_ATTRIBUTE_NORETURN ~FatalMessageEmitter() { - stream() << std::endl; - ::abort(); -#ifdef LLVM_BUILTIN_UNREACHABLE - // Windows systems and possibly others don't declare abort() to be noreturn, - // so use the unreachable builtin to avoid a Clang self-host warning. - LLVM_BUILTIN_UNREACHABLE; -#endif - } - std::ostream& stream() { return std::cerr; } -}; - -// Helper class that allows an ostream to 'appear' as a void expression. -class OstreamVoidifier { - public: - // This has to be an operator with a precedence lower than << but - // higher than ?: - void operator&(std::ostream&) {} -}; - -} // namespace include_what_you_use - -// Usage: CHECK_(condition) << extra << information; -// The file, line, condition and extra information will be printed to cerr, -// then the program will abort. -#define CHECK_(x) (x) ? (void)0 : \ - ::include_what_you_use::OstreamVoidifier() & \ - ::include_what_you_use::FatalMessageEmitter( \ - __FILE__, __LINE__, #x).stream() -// Instead of CHECK_(false && "message") use CHECK_UNREACHABLE_("message"). -#define CHECK_UNREACHABLE_(message) \ - ::include_what_you_use::OstreamVoidifier() & \ - ::include_what_you_use::FatalMessageEmitter( \ - __FILE__, __LINE__, message).stream() - -#if defined(_WIN32) - -#define snprintf _snprintf - -#define NOMINMAX 1 // Prevent Windows headers from redefining min/max. -#include "Shlwapi.h" // for PathMatchSpecA - -// This undef is necessary to prevent conflicts between llvm -// and Windows headers. -// objbase.h has #define interface struct. -#undef interface - -inline bool GlobMatchesPath(const char *glob, const char *path) { - return PathMatchSpecA(path, glob); -} - -#else // #if defined(_WIN32) - -#include - -inline bool GlobMatchesPath(const char *glob, const char *path) { - return fnmatch(glob, path, FNM_PATHNAME) == 0; -} - -#endif // #if defined(_WIN32) - -#endif // INCLUDE_WHAT_YOU_USE_PORT_H_ diff --git a/qt5_11.imp b/qt5_11.imp new file mode 100644 index 0000000..9dfc58e --- /dev/null +++ b/qt5_11.imp @@ -0,0 +1,3853 @@ +# Do not edit! This file was generated by the script generate_qt_mappings.py. +[ + { symbol: [ "QAbstractRayCaster", "private", "", "public" ] }, + { symbol: [ "QComputeCommand", "private", "", "public" ] }, + { symbol: [ "Qt3DRender", "private", "", "public" ] }, + { symbol: [ "QGeometryFactoryPtr", "private", "", "public" ] }, + { symbol: [ "QTextureData", "private", "", "public" ] }, + { symbol: [ "QBufferPtr", "private", "", "public" ] }, + { symbol: [ "QTextureGeneratorPtr", "private", "", "public" ] }, + { symbol: [ "QShaderProgramBuilder", "private", "", "public" ] }, + { symbol: [ "QTextureImage", "private", "", "public" ] }, + { symbol: [ "QCamera", "private", "", "public" ] }, + { symbol: [ "QStencilTest", "private", "", "public" ] }, + { symbol: [ "QGeometry", "private", "", "public" ] }, + { symbol: [ "QRenderTargetOutput", "private", "", "public" ] }, + { symbol: [ "QPointLight", "private", "", "public" ] }, + { symbol: [ "QRenderTarget", "private", "", "public" ] }, + { symbol: [ "QObjectPicker", "private", "", "public" ] }, + { symbol: [ "QPaintedTextureImage", "private", "", "public" ] }, + { symbol: [ "QAbstractFunctor", "private", "", "public" ] }, + { symbol: [ "Qt3DRenderVersion", "private", "", "public" ] }, + { symbol: [ "QRenderPass", "private", "", "public" ] }, + { symbol: [ "QPickLineEventPtr", "private", "", "public" ] }, + { symbol: [ "QRenderStateSet", "private", "", "public" ] }, + { symbol: [ "QTextureDataPtr", "private", "", "public" ] }, + { symbol: [ "QRenderCapture", "private", "", "public" ] }, + { symbol: [ "QDepthTest", "private", "", "public" ] }, + { symbol: [ "QBufferDataGeneratorPtr", "private", "", "public" ] }, + { symbol: [ "QBuffer", "private", "", "public" ] }, + { symbol: [ "QTechniqueFilter", "private", "", "public" ] }, + { symbol: [ "QRenderPassFilter", "private", "", "public" ] }, + { symbol: [ "QLayer", "private", "", "public" ] }, + { symbol: [ "QFrameGraphNodeCreatedChangeBase", "private", "", "public" ] }, + { symbol: [ "Qt3DRenderDepends", "private", "", "public" ] }, + { symbol: [ "QSeamlessCubemap", "private", "", "public" ] }, + { symbol: [ "QClearBuffers", "private", "", "public" ] }, + { symbol: [ "QTextureImageData", "private", "", "public" ] }, + { symbol: [ "QShaderProgram", "private", "", "public" ] }, + { symbol: [ "QParameter", "private", "", "public" ] }, + { symbol: [ "PropertyReaderInterfacePtr", "private", "", "public" ] }, + { symbol: [ "QSortPolicy", "private", "", "public" ] }, + { symbol: [ "QGeometryFactory", "private", "", "public" ] }, + { symbol: [ "QFrontFace", "private", "", "public" ] }, + { symbol: [ "QTextureImageDataGeneratorPtr", "private", "", "public" ] }, + { symbol: [ "QNoDepthMask", "private", "", "public" ] }, + { symbol: [ "QRayCaster", "private", "", "public" ] }, + { symbol: [ "QViewport", "private", "", "public" ] }, + { symbol: [ "QRenderCaptureReply", "private", "", "public" ] }, + { symbol: [ "ParameterList", "private", "", "public" ] }, + { symbol: [ "QPickEventPtr", "private", "", "public" ] }, + { symbol: [ "QBlitFramebuffer", "private", "", "public" ] }, + { symbol: [ "QPickTriangleEvent", "private", "", "public" ] }, + { symbol: [ "QLevelOfDetailBoundingSphere", "private", "", "public" ] }, + { symbol: [ "QBlendEquation", "private", "", "public" ] }, + { symbol: [ "QMemoryBarrier", "private", "", "public" ] }, + { symbol: [ "QFrameGraphNode", "private", "", "public" ] }, + { symbol: [ "QPickTriangleEventPtr", "private", "", "public" ] }, + { symbol: [ "QFilterKey", "private", "", "public" ] }, + { symbol: [ "QPickEvent", "private", "", "public" ] }, + { symbol: [ "QGeometryRenderer", "private", "", "public" ] }, + { symbol: [ "FunctorType", "private", "", "public" ] }, + { symbol: [ "QScreenRayCaster", "private", "", "public" ] }, + { symbol: [ "QFrameGraphNodeCreatedChange", "private", "", "public" ] }, + { symbol: [ "QEnvironmentLight", "private", "", "public" ] }, + { symbol: [ "QAlphaCoverage", "private", "", "public" ] }, + { symbol: [ "QAbstractTextureImage", "private", "", "public" ] }, + { symbol: [ "QSpotLight", "private", "", "public" ] }, + { symbol: [ "QRenderState", "private", "", "public" ] }, + { symbol: [ "QTextureImageDataPtr", "private", "", "public" ] }, + { symbol: [ "QPointSize", "private", "", "public" ] }, + { symbol: [ "QScissorTest", "private", "", "public" ] }, + { symbol: [ "QEffect", "private", "", "public" ] }, + { symbol: [ "QBufferDataGenerator", "private", "", "public" ] }, + { symbol: [ "QPolygonOffset", "private", "", "public" ] }, + { symbol: [ "QColorMask", "private", "", "public" ] }, + { symbol: [ "QBufferCapture", "private", "", "public" ] }, + { symbol: [ "QStencilTestArguments", "private", "", "public" ] }, + { symbol: [ "QPickPointEventPtr", "private", "", "public" ] }, + { symbol: [ "QGraphicsApiFilter", "private", "", "public" ] }, + { symbol: [ "QCameraLens", "private", "", "public" ] }, + { symbol: [ "QTextureImageDataGenerator", "private", "", "public" ] }, + { symbol: [ "QPickPointEvent", "private", "", "public" ] }, + { symbol: [ "QTexture", "private", "", "public" ] }, + { symbol: [ "PropertyReaderInterface", "private", "", "public" ] }, + { symbol: [ "QMultiSampleAntiAliasing", "private", "", "public" ] }, + { symbol: [ "QAlphaTest", "private", "", "public" ] }, + { symbol: [ "QTechnique", "private", "", "public" ] }, + { symbol: [ "QFrustumCulling", "private", "", "public" ] }, + { symbol: [ "QPickingSettings", "private", "", "public" ] }, + { symbol: [ "QRenderTargetSelector", "private", "", "public" ] }, + { symbol: [ "QStencilOperationArguments", "private", "", "public" ] }, + { symbol: [ "QRenderSurfaceSelector", "private", "", "public" ] }, + { symbol: [ "QDithering", "private", "", "public" ] }, + { symbol: [ "QClipPlane", "private", "", "public" ] }, + { symbol: [ "QAttribute", "private", "", "public" ] }, + { symbol: [ "QProximityFilter", "private", "", "public" ] }, + { symbol: [ "QBlendEquationArguments", "private", "", "public" ] }, + { symbol: [ "QMaterial", "private", "", "public" ] }, + { symbol: [ "QLevelOfDetail", "private", "", "public" ] }, + { symbol: [ "QFrameGraphNodeCreatedChangeBasePtr", "private", "", "public" ] }, + { symbol: [ "QCullFace", "private", "", "public" ] }, + { symbol: [ "QTextureWrapMode", "private", "", "public" ] }, + { symbol: [ "QDispatchCompute", "private", "", "public" ] }, + { symbol: [ "QAbstractTexture", "private", "", "public" ] }, + { symbol: [ "QRenderSettings", "private", "", "public" ] }, + { symbol: [ "QStencilMask", "private", "", "public" ] }, + { symbol: [ "QRayCasterHit", "private", "", "public" ] }, + { symbol: [ "QDirectionalLight", "private", "", "public" ] }, + { symbol: [ "QTextureGenerator", "private", "", "public" ] }, + { symbol: [ "QNoDraw", "private", "", "public" ] }, + { symbol: [ "QAbstractLight", "private", "", "public" ] }, + { symbol: [ "QStencilOperation", "private", "", "public" ] }, + { symbol: [ "QSceneLoader", "private", "", "public" ] }, + { symbol: [ "QRenderAspect", "private", "", "public" ] }, + { symbol: [ "QPickLineEvent", "private", "", "public" ] }, + { symbol: [ "QShaderData", "private", "", "public" ] }, + { symbol: [ "QLayerFilter", "private", "", "public" ] }, + { symbol: [ "QCameraSelector", "private", "", "public" ] }, + { symbol: [ "QtEglSupport", "private", "", "public" ] }, + { symbol: [ "QtEglSupportDepends", "private", "", "public" ] }, + { symbol: [ "QtEglSupportVersion", "private", "", "public" ] }, + { symbol: [ "QtPositioningQuick", "private", "", "public" ] }, + { symbol: [ "QtPositioningQuickVersion", "private", "", "public" ] }, + { symbol: [ "QtPositioningQuickDepends", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_3_2_Core", "private", "", "public" ] }, + { symbol: [ "QValidator", "private", "", "public" ] }, + { symbol: [ "QList", "private", "", "public" ] }, + { symbol: [ "QMatrix3x3", "private", "", "public" ] }, + { symbol: [ "QGenericPlugin", "private", "", "public" ] }, + { symbol: [ "QIconEngineV2", "private", "", "public" ] }, + { symbol: [ "QHelpEvent", "private", "", "public" ] }, + { symbol: [ "QOpenGLVertexArrayObject", "private", "", "public" ] }, + { symbol: [ "QPictureIO", "private", "", "public" ] }, + { symbol: [ "QOpenGLTimeMonitor", "private", "", "public" ] }, + { symbol: [ "QMatrix2x3", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions", "private", "", "public" ] }, + { symbol: [ "QIconDragEvent", "private", "", "public" ] }, + { symbol: [ "QMatrix4x3", "private", "", "public" ] }, + { symbol: [ "QPaintDeviceWindow", "private", "", "public" ] }, + { symbol: [ "QAccessibleTextSelectionEvent", "private", "", "public" ] }, + { symbol: [ "QTextDocument", "private", "", "public" ] }, + { symbol: [ "QAccessibleTextUpdateEvent", "private", "", "public" ] }, + { symbol: [ "QAccessibleInterface", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_4_1_Core", "private", "", "public" ] }, + { symbol: [ "QHoverEvent", "private", "", "public" ] }, + { symbol: [ "QPageSize", "private", "", "public" ] }, + { symbol: [ "QtGui", "private", "", "public" ] }, + { symbol: [ "QDragEnterEvent", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_4_0_Compatibility", "private", "", "public" ] }, + { symbol: [ "QTextTableFormat", "private", "", "public" ] }, + { symbol: [ "QTextListFormat", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_4_2_Compatibility", "private", "", "public" ] }, + { symbol: [ "QtGuiDepends", "private", "", "public" ] }, + { symbol: [ "QTextItem", "private", "", "public" ] }, + { symbol: [ "QOpenGLTexture", "private", "", "public" ] }, + { symbol: [ "QDragLeaveEvent", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_4_3_Core", "private", "", "public" ] }, + { symbol: [ "QEnterEvent", "private", "", "public" ] }, + { symbol: [ "QAccessiblePlugin", "private", "", "public" ] }, + { symbol: [ "QBrushData", "private", "", "public" ] }, + { symbol: [ "QMouseEvent", "private", "", "public" ] }, + { symbol: [ "QOpenGLExtraFunctions", "private", "", "public" ] }, + { symbol: [ "QBitmap", "private", "", "public" ] }, + { symbol: [ "QClipboard", "private", "", "public" ] }, + { symbol: [ "QTouchDevice", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_4_5_Core", "private", "", "public" ] }, + { symbol: [ "QWidgetSet", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_2_1", "private", "", "public" ] }, + { symbol: [ "QImageWriter", "private", "", "public" ] }, + { symbol: [ "QTextFragment", "private", "", "public" ] }, + { symbol: [ "QStandardItemModel", "private", "", "public" ] }, + { symbol: [ "QVulkanWindowRenderer", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_3_2_Compatibility", "private", "", "public" ] }, + { symbol: [ "QMatrix", "private", "", "public" ] }, + { symbol: [ "QPolygon", "private", "", "public" ] }, + { symbol: [ "QtEvents", "private", "", "public" ] }, + { symbol: [ "QAccessibleTableCellInterface", "private", "", "public" ] }, + { symbol: [ "QVulkanWindow", "private", "", "public" ] }, + { symbol: [ "QAccessibleEvent", "private", "", "public" ] }, + { symbol: [ "QAccessibleValueChangeEvent", "private", "", "public" ] }, + { symbol: [ "QRegExpValidator", "private", "", "public" ] }, + { symbol: [ "QLinearGradient", "private", "", "public" ] }, + { symbol: [ "QIcon", "private", "", "public" ] }, + { symbol: [ "QOpenGLFramebufferObjectFormat", "private", "", "public" ] }, + { symbol: [ "QShortcutEvent", "private", "", "public" ] }, + { symbol: [ "QCloseEvent", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_4_4_Core", "private", "", "public" ] }, + { symbol: [ "QAccessibleObject", "private", "", "public" ] }, + { symbol: [ "QGradient", "private", "", "public" ] }, + { symbol: [ "QTextInlineObject", "private", "", "public" ] }, + { symbol: [ "QFont", "private", "", "public" ] }, + { symbol: [ "QPen", "private", "", "public" ] }, + { symbol: [ "QImageCleanupFunction", "private", "", "public" ] }, + { symbol: [ "QPixmap", "private", "", "public" ] }, + { symbol: [ "QDragMoveEvent", "private", "", "public" ] }, + { symbol: [ "QAccessibleImageInterface", "private", "", "public" ] }, + { symbol: [ "QResizeEvent", "private", "", "public" ] }, + { symbol: [ "QKeyEvent", "private", "", "public" ] }, + { symbol: [ "QFontDatabase", "private", "", "public" ] }, + { symbol: [ "QStaticText", "private", "", "public" ] }, + { symbol: [ "QContextMenuEvent", "private", "", "public" ] }, + { symbol: [ "QImage", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_3_1", "private", "", "public" ] }, + { symbol: [ "QRadialGradient", "private", "", "public" ] }, + { symbol: [ "QPagedPaintDevice", "private", "", "public" ] }, + { symbol: [ "QSurface", "private", "", "public" ] }, + { symbol: [ "QScrollEvent", "private", "", "public" ] }, + { symbol: [ "QImageIOPlugin", "private", "", "public" ] }, + { symbol: [ "QPixmapCache", "private", "", "public" ] }, + { symbol: [ "QOpenGLBuffer", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_1_0", "private", "", "public" ] }, + { symbol: [ "QPaintDevice", "private", "", "public" ] }, + { symbol: [ "QOpenGLDebugMessage", "private", "", "public" ] }, + { symbol: [ "QScreen", "private", "", "public" ] }, + { symbol: [ "QPaintEngine", "private", "", "public" ] }, + { symbol: [ "QOpenGLVersionProfile", "private", "", "public" ] }, + { symbol: [ "QInputMethod", "private", "", "public" ] }, + { symbol: [ "QTextObject", "private", "", "public" ] }, + { symbol: [ "QSessionManager", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_3_0", "private", "", "public" ] }, + { symbol: [ "QVulkanLayer", "private", "", "public" ] }, + { symbol: [ "QShowEvent", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_1_3", "private", "", "public" ] }, + { symbol: [ "QVector2D", "private", "", "public" ] }, + { symbol: [ "QAccessibleTextRemoveEvent", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_4_5_Compatibility", "private", "", "public" ] }, + { symbol: [ "QPageLayout", "private", "", "public" ] }, + { symbol: [ "QAccessibleTableModelChangeEvent", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctionsPrivate", "private", "", "public" ] }, + { symbol: [ "QTextLine", "private", "", "public" ] }, + { symbol: [ "QAccessible", "private", "", "public" ] }, + { symbol: [ "QPolygonF", "private", "", "public" ] }, + { symbol: [ "QDrag", "private", "", "public" ] }, + { symbol: [ "QPixelFormat", "private", "", "public" ] }, + { symbol: [ "QPainterPathStroker", "private", "", "public" ] }, + { symbol: [ "QOpenGLPixelTransferOptions", "private", "", "public" ] }, + { symbol: [ "QFontMetrics", "private", "", "public" ] }, + { symbol: [ "QPaintEngineState", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_4_0_Core", "private", "", "public" ] }, + { symbol: [ "QToolBarChangeEvent", "private", "", "public" ] }, + { symbol: [ "QVulkanFunctions", "private", "", "public" ] }, + { symbol: [ "QAccessibleTextCursorEvent", "private", "", "public" ] }, + { symbol: [ "QOpenGLShader", "private", "", "public" ] }, + { symbol: [ "QAccessibleStateChangeEvent", "private", "", "public" ] }, + { symbol: [ "QOpenGLContext", "private", "", "public" ] }, + { symbol: [ "QMatrix2x2", "private", "", "public" ] }, + { symbol: [ "QInputMethodQueryEvent", "private", "", "public" ] }, + { symbol: [ "QTransform", "private", "", "public" ] }, + { symbol: [ "QFontMetricsF", "private", "", "public" ] }, + { symbol: [ "QTextCursor", "private", "", "public" ] }, + { symbol: [ "QtGuiVersion", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_1_4", "private", "", "public" ] }, + { symbol: [ "QWidgetList", "private", "", "public" ] }, + { symbol: [ "QTextLayout", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_4_3_Compatibility", "private", "", "public" ] }, + { symbol: [ "QTextBlockFormat", "private", "", "public" ] }, + { symbol: [ "QInputEvent", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_1_5", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_4_2_Core", "private", "", "public" ] }, + { symbol: [ "QIntValidator", "private", "", "public" ] }, + { symbol: [ "QOpenGLFramebufferObject", "private", "", "public" ] }, + { symbol: [ "QTextImageFormat", "private", "", "public" ] }, + { symbol: [ "QPictureFormatPlugin", "private", "", "public" ] }, + { symbol: [ "QAccessibleBridgePlugin", "private", "", "public" ] }, + { symbol: [ "QMoveEvent", "private", "", "public" ] }, + { symbol: [ "QOpenGLDebugLogger", "private", "", "public" ] }, + { symbol: [ "QVulkanDeviceFunctions", "private", "", "public" ] }, + { symbol: [ "QTextBlockGroup", "private", "", "public" ] }, + { symbol: [ "QMatrix4x2", "private", "", "public" ] }, + { symbol: [ "QCursor", "private", "", "public" ] }, + { symbol: [ "QPlatformSurfaceEvent", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_ES2", "private", "", "public" ] }, + { symbol: [ "QOpenGLVersionFunctions", "private", "", "public" ] }, + { symbol: [ "QPointingDeviceUniqueId", "private", "", "public" ] }, + { symbol: [ "QAbstractTextDocumentLayout", "private", "", "public" ] }, + { symbol: [ "QAccessibleTextInterface", "private", "", "public" ] }, + { symbol: [ "QWidgetMapper", "private", "", "public" ] }, + { symbol: [ "QKeySequence", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_1_2", "private", "", "public" ] }, + { symbol: [ "QHideEvent", "private", "", "public" ] }, + { symbol: [ "QMatrix3x2", "private", "", "public" ] }, + { symbol: [ "QWindowStateChangeEvent", "private", "", "public" ] }, + { symbol: [ "QAccessibleBridge", "private", "", "public" ] }, + { symbol: [ "QOpenGLShaderProgram", "private", "", "public" ] }, + { symbol: [ "QFontInfo", "private", "", "public" ] }, + { symbol: [ "QTouchEvent", "private", "", "public" ] }, + { symbol: [ "QTextObjectInterface", "private", "", "public" ] }, + { symbol: [ "QTextFrameFormat", "private", "", "public" ] }, + { symbol: [ "QAccessibleTableInterface", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_2_0", "private", "", "public" ] }, + { symbol: [ "QVulkanExtension", "private", "", "public" ] }, + { symbol: [ "QImageReader", "private", "", "public" ] }, + { symbol: [ "QNativeGestureEvent", "private", "", "public" ] }, + { symbol: [ "QPainter", "private", "", "public" ] }, + { symbol: [ "QTextBlock", "private", "", "public" ] }, + { symbol: [ "QImageIOHandler", "private", "", "public" ] }, + { symbol: [ "QPdfWriter", "private", "", "public" ] }, + { symbol: [ "QTextTableCellFormat", "private", "", "public" ] }, + { symbol: [ "QTextFrameLayoutData", "private", "", "public" ] }, + { symbol: [ "QTextTable", "private", "", "public" ] }, + { symbol: [ "QOpenGLTimerQuery", "private", "", "public" ] }, + { symbol: [ "QOpenGLExtraFunctionsPrivate", "private", "", "public" ] }, + { symbol: [ "QOpenGLWindow", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_4_4_Compatibility", "private", "", "public" ] }, + { symbol: [ "QWhatsThisClickedEvent", "private", "", "public" ] }, + { symbol: [ "QOpenGLContextGroup", "private", "", "public" ] }, + { symbol: [ "QGradientStop", "private", "", "public" ] }, + { symbol: [ "QWindowList", "private", "", "public" ] }, + { symbol: [ "QScrollPrepareEvent", "private", "", "public" ] }, + { symbol: [ "QWheelEvent", "private", "", "public" ] }, + { symbol: [ "QOpenGLTextureBlitter", "private", "", "public" ] }, + { symbol: [ "QGlyphRun", "private", "", "public" ] }, + { symbol: [ "QAccessibleTextInsertEvent", "private", "", "public" ] }, + { symbol: [ "QRegularExpressionValidator", "private", "", "public" ] }, + { symbol: [ "QAccessibleActionInterface", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_4_1_Compatibility", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_1_1", "private", "", "public" ] }, + { symbol: [ "QStatusTipEvent", "private", "", "public" ] }, + { symbol: [ "QIconEngine", "private", "", "public" ] }, + { symbol: [ "QGenericPluginFactory", "private", "", "public" ] }, + { symbol: [ "QGradientStops", "private", "", "public" ] }, + { symbol: [ "QTextBlockUserData", "private", "", "public" ] }, + { symbol: [ "QTextCharFormat", "private", "", "public" ] }, + { symbol: [ "QMatrix3x4", "private", "", "public" ] }, + { symbol: [ "QExposeEvent", "private", "", "public" ] }, + { symbol: [ "QMovie", "private", "", "public" ] }, + { symbol: [ "QGenericMatrix", "private", "", "public" ] }, + { symbol: [ "QSurfaceFormat", "private", "", "public" ] }, + { symbol: [ "QVulkanInstance", "private", "", "public" ] }, + { symbol: [ "QGuiApplication", "private", "", "public" ] }, + { symbol: [ "QFocusEvent", "private", "", "public" ] }, + { symbol: [ "QMatrix4x4", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_3_3_Compatibility", "private", "", "public" ] }, + { symbol: [ "QFileOpenEvent", "private", "", "public" ] }, + { symbol: [ "QPicture", "private", "", "public" ] }, + { symbol: [ "QRasterWindow", "private", "", "public" ] }, + { symbol: [ "QInputMethodEvent", "private", "", "public" ] }, + { symbol: [ "QStyleHints", "private", "", "public" ] }, + { symbol: [ "QRgb", "private", "", "public" ] }, + { symbol: [ "QIconEnginePlugin", "private", "", "public" ] }, + { symbol: [ "QPalette", "private", "", "public" ] }, + { symbol: [ "QTextFrame", "private", "", "public" ] }, + { symbol: [ "QRegion", "private", "", "public" ] }, + { symbol: [ "QRawFont", "private", "", "public" ] }, + { symbol: [ "QTextList", "private", "", "public" ] }, + { symbol: [ "QDoubleValidator", "private", "", "public" ] }, + { symbol: [ "QImageTextKeyLang", "private", "", "public" ] }, + { symbol: [ "QTextDocumentWriter", "private", "", "public" ] }, + { symbol: [ "QActionEvent", "private", "", "public" ] }, + { symbol: [ "QOffscreenSurface", "private", "", "public" ] }, + { symbol: [ "QQuaternion", "private", "", "public" ] }, + { symbol: [ "QVulkanInfoVector", "private", "", "public" ] }, + { symbol: [ "QDesktopServices", "private", "", "public" ] }, + { symbol: [ "QTextFormat", "private", "", "public" ] }, + { symbol: [ "QTextDocumentFragment", "private", "", "public" ] }, + { symbol: [ "QDropEvent", "private", "", "public" ] }, + { symbol: [ "QSyntaxHighlighter", "private", "", "public" ] }, + { symbol: [ "QColor", "private", "", "public" ] }, + { symbol: [ "QPaintEvent", "private", "", "public" ] }, + { symbol: [ "QAccessibleEditableTextInterface", "private", "", "public" ] }, + { symbol: [ "QVector4D", "private", "", "public" ] }, + { symbol: [ "QRgba64", "private", "", "public" ] }, + { symbol: [ "QStandardItem", "private", "", "public" ] }, + { symbol: [ "QApplicationStateChangeEvent", "private", "", "public" ] }, + { symbol: [ "QVector3D", "private", "", "public" ] }, + { symbol: [ "QBackingStore", "private", "", "public" ] }, + { symbol: [ "QTextOption", "private", "", "public" ] }, + { symbol: [ "QAccessibleValueInterface", "private", "", "public" ] }, + { symbol: [ "QConicalGradient", "private", "", "public" ] }, + { symbol: [ "QAbstractUndoItem", "private", "", "public" ] }, + { symbol: [ "QTabletEvent", "private", "", "public" ] }, + { symbol: [ "QTextTableCell", "private", "", "public" ] }, + { symbol: [ "QWindow", "private", "", "public" ] }, + { symbol: [ "QOpenGLFunctions_3_3_Core", "private", "", "public" ] }, + { symbol: [ "QOpenGLPaintDevice", "private", "", "public" ] }, + { symbol: [ "QAccessibleApplication", "private", "", "public" ] }, + { symbol: [ "QScreenOrientationChangeEvent", "private", "", "public" ] }, + { symbol: [ "QMatrix2x4", "private", "", "public" ] }, + { symbol: [ "QWebFrame", "private", "", "public" ] }, + { symbol: [ "QtWebKitWidgets", "private", "", "public" ] }, + { symbol: [ "QWebView", "private", "", "public" ] }, + { symbol: [ "QtWebKitWidgetsDepends", "private", "", "public" ] }, + { symbol: [ "QWebInspector", "private", "", "public" ] }, + { symbol: [ "QtWebKitWidgetsVersion", "private", "", "public" ] }, + { symbol: [ "QWebPage", "private", "", "public" ] }, + { symbol: [ "QGraphicsWebView", "private", "", "public" ] }, + { symbol: [ "QWebHitTestResult", "private", "", "public" ] }, + { symbol: [ "QTestKeyEvent", "private", "", "public" ] }, + { symbol: [ "QtTestGui", "private", "", "public" ] }, + { symbol: [ "QTestData", "private", "", "public" ] }, + { symbol: [ "QtTestDepends", "private", "", "public" ] }, + { symbol: [ "QTestAccessibility", "private", "", "public" ] }, + { symbol: [ "QtTest", "private", "", "public" ] }, + { symbol: [ "QtTestVersion", "private", "", "public" ] }, + { symbol: [ "QTest", "private", "", "public" ] }, + { symbol: [ "QSpontaneKeyEvent", "private", "", "public" ] }, + { symbol: [ "QTestDelayEvent", "private", "", "public" ] }, + { symbol: [ "QtTestNetwork", "private", "", "public" ] }, + { symbol: [ "QSignalSpy", "private", "", "public" ] }, + { symbol: [ "QTestEventLoop", "private", "", "public" ] }, + { symbol: [ "QTestMouseEvent", "private", "", "public" ] }, + { symbol: [ "QtTestWidgets", "private", "", "public" ] }, + { symbol: [ "QTestEventList", "private", "", "public" ] }, + { symbol: [ "QTestEvent", "private", "", "public" ] }, + { symbol: [ "QAbstractItemModelTester", "private", "", "public" ] }, + { symbol: [ "QEventSizeOfChecker", "private", "", "public" ] }, + { symbol: [ "QTestKeyClicksEvent", "private", "", "public" ] }, + { symbol: [ "QtNetworkVersion", "private", "", "public" ] }, + { symbol: [ "QNetworkConfiguration", "private", "", "public" ] }, + { symbol: [ "QNetworkCacheMetaData", "private", "", "public" ] }, + { symbol: [ "QNetworkDatagram", "private", "", "public" ] }, + { symbol: [ "QNetworkProxyFactory", "private", "", "public" ] }, + { symbol: [ "QHstsPolicy", "private", "", "public" ] }, + { symbol: [ "QSslKey", "private", "", "public" ] }, + { symbol: [ "QNetworkSession", "private", "", "public" ] }, + { symbol: [ "QtNetwork", "private", "", "public" ] }, + { symbol: [ "QSslSocket", "private", "", "public" ] }, + { symbol: [ "QLocalServer", "private", "", "public" ] }, + { symbol: [ "QSslCipher", "private", "", "public" ] }, + { symbol: [ "QSslError", "private", "", "public" ] }, + { symbol: [ "QtNetworkDepends", "private", "", "public" ] }, + { symbol: [ "QDnsLookup", "private", "", "public" ] }, + { symbol: [ "QHttpMultiPart", "private", "", "public" ] }, + { symbol: [ "QNetworkAccessManager", "private", "", "public" ] }, + { symbol: [ "QSslConfiguration", "private", "", "public" ] }, + { symbol: [ "QNetworkConfigurationManager", "private", "", "public" ] }, + { symbol: [ "QNetworkCookieJar", "private", "", "public" ] }, + { symbol: [ "QDnsMailExchangeRecord", "private", "", "public" ] }, + { symbol: [ "QDnsTextRecord", "private", "", "public" ] }, + { symbol: [ "QHttpPart", "private", "", "public" ] }, + { symbol: [ "QNetworkReply", "private", "", "public" ] }, + { symbol: [ "QHostAddress", "private", "", "public" ] }, + { symbol: [ "Q_IPV6ADDR", "private", "", "public" ] }, + { symbol: [ "QSslPreSharedKeyAuthenticator", "private", "", "public" ] }, + { symbol: [ "QLocalSocket", "private", "", "public" ] }, + { symbol: [ "QNetworkAddressEntry", "private", "", "public" ] }, + { symbol: [ "QIPv6Address", "private", "", "public" ] }, + { symbol: [ "QNetworkInterface", "private", "", "public" ] }, + { symbol: [ "QSctpSocket", "private", "", "public" ] }, + { symbol: [ "QTcpSocket", "private", "", "public" ] }, + { symbol: [ "QNetworkProxy", "private", "", "public" ] }, + { symbol: [ "QNetworkDiskCache", "private", "", "public" ] }, + { symbol: [ "QSctpServer", "private", "", "public" ] }, + { symbol: [ "QAbstractSocket", "private", "", "public" ] }, + { symbol: [ "QUdpSocket", "private", "", "public" ] }, + { symbol: [ "QAuthenticator", "private", "", "public" ] }, + { symbol: [ "QNetworkProxyQuery", "private", "", "public" ] }, + { symbol: [ "QDnsDomainNameRecord", "private", "", "public" ] }, + { symbol: [ "QHostInfo", "private", "", "public" ] }, + { symbol: [ "QSsl", "private", "", "public" ] }, + { symbol: [ "QSslDiffieHellmanParameters", "private", "", "public" ] }, + { symbol: [ "QNetworkRequest", "private", "", "public" ] }, + { symbol: [ "QSslEllipticCurve", "private", "", "public" ] }, + { symbol: [ "QSslCertificateExtension", "private", "", "public" ] }, + { symbol: [ "QDnsHostAddressRecord", "private", "", "public" ] }, + { symbol: [ "QAbstractNetworkCache", "private", "", "public" ] }, + { symbol: [ "QTcpServer", "private", "", "public" ] }, + { symbol: [ "QDnsServiceRecord", "private", "", "public" ] }, + { symbol: [ "QNetworkCookie", "private", "", "public" ] }, + { symbol: [ "QSslCertificate", "private", "", "public" ] }, + { symbol: [ "QtEglFSDeviceIntegration", "private", "", "public" ] }, + { symbol: [ "QtEglFSDeviceIntegrationDepends", "private", "", "public" ] }, + { symbol: [ "QtEglFSDeviceIntegrationVersion", "private", "", "public" ] }, + { symbol: [ "QDBusAbstractInterfaceBase", "private", "", "public" ] }, + { symbol: [ "QDBusVariant", "private", "", "public" ] }, + { symbol: [ "QDBusPendingCall", "private", "", "public" ] }, + { symbol: [ "QDBusConnection", "private", "", "public" ] }, + { symbol: [ "QDBusInterface", "private", "", "public" ] }, + { symbol: [ "QDBusUnixFileDescriptor", "private", "", "public" ] }, + { symbol: [ "QtDBus", "private", "", "public" ] }, + { symbol: [ "QDBusAbstractAdaptor", "private", "", "public" ] }, + { symbol: [ "QDBusContext", "private", "", "public" ] }, + { symbol: [ "QDBusMetaType", "private", "", "public" ] }, + { symbol: [ "QDBusArgument", "private", "", "public" ] }, + { symbol: [ "QtDBusVersion", "private", "", "public" ] }, + { symbol: [ "QDBusServer", "private", "", "public" ] }, + { symbol: [ "QDBusPendingReplyData", "private", "", "public" ] }, + { symbol: [ "QDBusServiceWatcher", "private", "", "public" ] }, + { symbol: [ "QDBusReply", "private", "", "public" ] }, + { symbol: [ "QtDBusDepends", "private", "", "public" ] }, + { symbol: [ "QDBusAbstractInterface", "private", "", "public" ] }, + { symbol: [ "QDBusPendingCallWatcher", "private", "", "public" ] }, + { symbol: [ "QDBusPendingReply", "private", "", "public" ] }, + { symbol: [ "QDBusSignature", "private", "", "public" ] }, + { symbol: [ "QDBusConnectionInterface", "private", "", "public" ] }, + { symbol: [ "QDBusVirtualObject", "private", "", "public" ] }, + { symbol: [ "QDBusError", "private", "", "public" ] }, + { symbol: [ "QDBusMessage", "private", "", "public" ] }, + { symbol: [ "QtPrintSupportDepends", "private", "", "public" ] }, + { symbol: [ "QtPrintSupport", "private", "", "public" ] }, + { symbol: [ "QPrinterInfo", "private", "", "public" ] }, + { symbol: [ "QPrinter", "private", "", "public" ] }, + { symbol: [ "QPrintEngine", "private", "", "public" ] }, + { symbol: [ "QtPrintSupportVersion", "private", "", "public" ] }, + { symbol: [ "QPageSetupDialog", "private", "", "public" ] }, + { symbol: [ "QPrintDialog", "private", "", "public" ] }, + { symbol: [ "QPrintPreviewDialog", "private", "", "public" ] }, + { symbol: [ "QPrintPreviewWidget", "private", "", "public" ] }, + { symbol: [ "QAbstractPrintDialog", "private", "", "public" ] }, + { symbol: [ "QGeoPositionInfo", "private", "", "public" ] }, + { symbol: [ "QGeoAreaMonitorInfo", "private", "", "public" ] }, + { symbol: [ "QGeoRectangle", "private", "", "public" ] }, + { symbol: [ "QGeoSatelliteInfoSource", "private", "", "public" ] }, + { symbol: [ "QGeoCoordinate", "private", "", "public" ] }, + { symbol: [ "QtPositioning", "private", "", "public" ] }, + { symbol: [ "QGeoPositionInfoSourceFactory", "private", "", "public" ] }, + { symbol: [ "QGeoLocation", "private", "", "public" ] }, + { symbol: [ "QGeoPolygonPrivate", "private", "", "public" ] }, + { symbol: [ "QGeoCircle", "private", "", "public" ] }, + { symbol: [ "QGeoSatelliteInfo", "private", "", "public" ] }, + { symbol: [ "QtPositioningDepends", "private", "", "public" ] }, + { symbol: [ "QGeoAddress", "private", "", "public" ] }, + { symbol: [ "QGeoPositionInfoSource", "private", "", "public" ] }, + { symbol: [ "QGeoPolygon", "private", "", "public" ] }, + { symbol: [ "QGeoAreaMonitorSource", "private", "", "public" ] }, + { symbol: [ "QtPositioningVersion", "private", "", "public" ] }, + { symbol: [ "QGeoShape", "private", "", "public" ] }, + { symbol: [ "QNmeaPositionInfoSource", "private", "", "public" ] }, + { symbol: [ "QtSvg", "private", "", "public" ] }, + { symbol: [ "QtSvgDepends", "private", "", "public" ] }, + { symbol: [ "QGraphicsSvgItem", "private", "", "public" ] }, + { symbol: [ "QSvgGenerator", "private", "", "public" ] }, + { symbol: [ "QSvgWidget", "private", "", "public" ] }, + { symbol: [ "QSvgRenderer", "private", "", "public" ] }, + { symbol: [ "QtSvgVersion", "private", "", "public" ] }, + { symbol: [ "QtThemeSupportDepends", "private", "", "public" ] }, + { symbol: [ "QtThemeSupportVersion", "private", "", "public" ] }, + { symbol: [ "QtThemeSupport", "private", "", "public" ] }, + { symbol: [ "Qt3DQuickRenderVersion", "private", "", "public" ] }, + { symbol: [ "Qt3DQuickRenderDepends", "private", "", "public" ] }, + { symbol: [ "Qt3DQuickRender", "private", "", "public" ] }, + { symbol: [ "QtQuickTestDepends", "private", "", "public" ] }, + { symbol: [ "QtQuickTest", "private", "", "public" ] }, + { symbol: [ "QtQuickTestVersion", "private", "", "public" ] }, + { symbol: [ "QtQmlDebugDepends", "private", "", "public" ] }, + { symbol: [ "QtQmlDebugVersion", "private", "", "public" ] }, + { symbol: [ "QtQmlDebug", "private", "", "public" ] }, + { symbol: [ "QSqlRelation", "private", "", "public" ] }, + { symbol: [ "QSqlField", "private", "", "public" ] }, + { symbol: [ "QSqlQueryModel", "private", "", "public" ] }, + { symbol: [ "QtSqlDepends", "private", "", "public" ] }, + { symbol: [ "QSqlError", "private", "", "public" ] }, + { symbol: [ "QSqlTableModel", "private", "", "public" ] }, + { symbol: [ "QSqlDriverCreatorBase", "private", "", "public" ] }, + { symbol: [ "QtSql", "private", "", "public" ] }, + { symbol: [ "QSqlRelationalTableModel", "private", "", "public" ] }, + { symbol: [ "QSqlQuery", "private", "", "public" ] }, + { symbol: [ "QSqlRelationalDelegate", "private", "", "public" ] }, + { symbol: [ "QtSqlVersion", "private", "", "public" ] }, + { symbol: [ "QSqlIndex", "private", "", "public" ] }, + { symbol: [ "QSqlDriverPlugin", "private", "", "public" ] }, + { symbol: [ "QSqlRecord", "private", "", "public" ] }, + { symbol: [ "QSqlDatabase", "private", "", "public" ] }, + { symbol: [ "QSqlDriverCreator", "private", "", "public" ] }, + { symbol: [ "QSqlResult", "private", "", "public" ] }, + { symbol: [ "QSqlDriver", "private", "", "public" ] }, + { symbol: [ "QSql", "private", "", "public" ] }, + { symbol: [ "QtGlxSupportDepends", "private", "", "public" ] }, + { symbol: [ "QtGlxSupport", "private", "", "public" ] }, + { symbol: [ "QtGlxSupportVersion", "private", "", "public" ] }, + { symbol: [ "QtPlatformCompositorSupportVersion", "private", "", "public" ] }, + { symbol: [ "QtPlatformCompositorSupportDepends", "private", "", "public" ] }, + { symbol: [ "QtPlatformCompositorSupport", "private", "", "public" ] }, + { symbol: [ "QXmlResultItems", "private", "", "public" ] }, + { symbol: [ "QXmlItem", "private", "", "public" ] }, + { symbol: [ "QXmlSchema", "private", "", "public" ] }, + { symbol: [ "QXmlSchemaValidator", "private", "", "public" ] }, + { symbol: [ "QXmlNamePool", "private", "", "public" ] }, + { symbol: [ "QAbstractMessageHandler", "private", "", "public" ] }, + { symbol: [ "QSimpleXmlNodeModel", "private", "", "public" ] }, + { symbol: [ "QXmlSerializer", "private", "", "public" ] }, + { symbol: [ "QtXmlPatternsDepends", "private", "", "public" ] }, + { symbol: [ "QtXmlPatterns", "private", "", "public" ] }, + { symbol: [ "QXmlName", "private", "", "public" ] }, + { symbol: [ "QAbstractUriResolver", "private", "", "public" ] }, + { symbol: [ "QXmlNodeModelIndex", "private", "", "public" ] }, + { symbol: [ "QtXmlPatternsVersion", "private", "", "public" ] }, + { symbol: [ "QAbstractXmlReceiver", "private", "", "public" ] }, + { symbol: [ "QXmlFormatter", "private", "", "public" ] }, + { symbol: [ "QAbstractXmlNodeModel", "private", "", "public" ] }, + { symbol: [ "QSourceLocation", "private", "", "public" ] }, + { symbol: [ "QXmlQuery", "private", "", "public" ] }, + { symbol: [ "QtAccessibilitySupportVersion", "private", "", "public" ] }, + { symbol: [ "QtAccessibilitySupport", "private", "", "public" ] }, + { symbol: [ "QtAccessibilitySupportDepends", "private", "", "public" ] }, + { symbol: [ "Qt3DQuickDepends", "private", "", "public" ] }, + { symbol: [ "QQmlAspectEngine", "private", "", "public" ] }, + { symbol: [ "Qt3DQuick", "private", "", "public" ] }, + { symbol: [ "Qt3DQuickVersion", "private", "", "public" ] }, + { symbol: [ "QWindowsWindowFunctions", "private", "", "public" ] }, + { symbol: [ "QXcbIntegrationFunctions", "private", "", "public" ] }, + { symbol: [ "QEGLNativeContext", "private", "", "public" ] }, + { symbol: [ "QPlatformHeaderHelper", "private", "", "public" ] }, + { symbol: [ "QtPlatformHeadersDepends", "private", "", "public" ] }, + { symbol: [ "QCocoaNativeContext", "private", "", "public" ] }, + { symbol: [ "QXcbWindowFunctions", "private", "", "public" ] }, + { symbol: [ "QEglFSFunctions", "private", "", "public" ] }, + { symbol: [ "QWaylandWindowFunctions", "private", "", "public" ] }, + { symbol: [ "QXcbScreenFunctions", "private", "", "public" ] }, + { symbol: [ "QtPlatformHeaders", "private", "", "public" ] }, + { symbol: [ "QWGLNativeContext", "private", "", "public" ] }, + { symbol: [ "QtPlatformHeadersVersion", "private", "", "public" ] }, + { symbol: [ "QGLXNativeContext", "private", "", "public" ] }, + { symbol: [ "QCocoaWindowFunctions", "private", "", "public" ] }, + { symbol: [ "QtKmsSupportDepends", "private", "", "public" ] }, + { symbol: [ "QtKmsSupport", "private", "", "public" ] }, + { symbol: [ "QtKmsSupportVersion", "private", "", "public" ] }, + { symbol: [ "QSceneChange", "private", "", "public" ] }, + { symbol: [ "QAspectJob", "private", "", "public" ] }, + { symbol: [ "QPropertyNodeAddedChangePtr", "private", "", "public" ] }, + { symbol: [ "Qt3DCoreDepends", "private", "", "public" ] }, + { symbol: [ "QSkeletonLoader", "private", "", "public" ] }, + { symbol: [ "QBackendNode", "private", "", "public" ] }, + { symbol: [ "QPropertyValueRemovedChange", "private", "", "public" ] }, + { symbol: [ "QPropertyUpdatedChangePtr", "private", "", "public" ] }, + { symbol: [ "QAbstractAspect", "private", "", "public" ] }, + { symbol: [ "QPropertyValueRemovedChangeBasePtr", "private", "", "public" ] }, + { symbol: [ "QPropertyNodeRemovedChangePtr", "private", "", "public" ] }, + { symbol: [ "QPropertyUpdatedChangeBase", "private", "", "public" ] }, + { symbol: [ "QSkeleton", "private", "", "public" ] }, + { symbol: [ "QNodeCommand", "private", "", "public" ] }, + { symbol: [ "QPropertyValueAddedChange", "private", "", "public" ] }, + { symbol: [ "QAspectJobPtr", "private", "", "public" ] }, + { symbol: [ "QAbstractSkeleton", "private", "", "public" ] }, + { symbol: [ "QDynamicPropertyUpdatedChange", "private", "", "public" ] }, + { symbol: [ "QStaticPropertyValueRemovedChangeBase", "private", "", "public" ] }, + { symbol: [ "QBackendNodeMapperPtr", "private", "", "public" ] }, + { symbol: [ "QComponentRemovedChange", "private", "", "public" ] }, + { symbol: [ "QPropertyValueAddedChangeBase", "private", "", "public" ] }, + { symbol: [ "QPropertyNodeAddedChange", "private", "", "public" ] }, + { symbol: [ "QBackendNodeMapper", "private", "", "public" ] }, + { symbol: [ "QStaticPropertyValueAddedChangeBase", "private", "", "public" ] }, + { symbol: [ "QNodeId", "private", "", "public" ] }, + { symbol: [ "QStaticPropertyUpdatedChangeBase", "private", "", "public" ] }, + { symbol: [ "QPropertyUpdatedChange", "private", "", "public" ] }, + { symbol: [ "QComponent", "private", "", "public" ] }, + { symbol: [ "QEntity", "private", "", "public" ] }, + { symbol: [ "QPropertyValueRemovedChangeBase", "private", "", "public" ] }, + { symbol: [ "QPropertyNodeRemovedChange", "private", "", "public" ] }, + { symbol: [ "QNodeCommandPtr", "private", "", "public" ] }, + { symbol: [ "QNodeVector", "private", "", "public" ] }, + { symbol: [ "QTransform", "private", "", "public" ] }, + { symbol: [ "Qt3DCore", "private", "", "public" ] }, + { symbol: [ "QNodeCreatedChange", "private", "", "public" ] }, + { symbol: [ "QAspectEngine", "private", "", "public" ] }, + { symbol: [ "QPropertyUpdatedChangeBasePtr", "private", "", "public" ] }, + { symbol: [ "QComponentVector", "private", "", "public" ] }, + { symbol: [ "QNodeDestroyedChange", "private", "", "public" ] }, + { symbol: [ "QStaticPropertyUpdatedChangeBasePtr", "private", "", "public" ] }, + { symbol: [ "Qt3DCoreVersion", "private", "", "public" ] }, + { symbol: [ "QNodeIdTypePair", "private", "", "public" ] }, + { symbol: [ "QComponentAddedChange", "private", "", "public" ] }, + { symbol: [ "QSceneChangePtr", "private", "", "public" ] }, + { symbol: [ "QNodeCreatedChangeBasePtr", "private", "", "public" ] }, + { symbol: [ "QNode", "private", "", "public" ] }, + { symbol: [ "QNodeCreatedChangeBase", "private", "", "public" ] }, + { symbol: [ "QArmature", "private", "", "public" ] }, + { symbol: [ "QNodePtr", "private", "", "public" ] }, + { symbol: [ "QPropertyValueAddedChangePtr", "private", "", "public" ] }, + { symbol: [ "QEntityPtr", "private", "", "public" ] }, + { symbol: [ "QComponentRemovedChangePtr", "private", "", "public" ] }, + { symbol: [ "QNodeDestroyedChangePtr", "private", "", "public" ] }, + { symbol: [ "QJoint", "private", "", "public" ] }, + { symbol: [ "QDynamicPropertyUpdatedChangePtr", "private", "", "public" ] }, + { symbol: [ "QPropertyValueAddedChangeBasePtr", "private", "", "public" ] }, + { symbol: [ "QPropertyValueRemovedChangePtr", "private", "", "public" ] }, + { symbol: [ "QComponentAddedChangePtr", "private", "", "public" ] }, + { symbol: [ "QtUiPluginDepends", "private", "", "public" ] }, + { symbol: [ "QtUiPluginVersion", "private", "", "public" ] }, + { symbol: [ "QDesignerCustomWidgetInterface", "private", "", "public" ] }, + { symbol: [ "QtUiPlugin", "private", "", "public" ] }, + { symbol: [ "QDesignerCustomWidgetCollectionInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerExportWidget", "private", "", "public" ] }, + { symbol: [ "QFrameAction", "private", "", "public" ] }, + { symbol: [ "Qt3DLogicDepends", "private", "", "public" ] }, + { symbol: [ "Qt3DLogic", "private", "", "public" ] }, + { symbol: [ "QLogicAspect", "private", "", "public" ] }, + { symbol: [ "Qt3DLogicVersion", "private", "", "public" ] }, + { symbol: [ "QtFbSupportVersion", "private", "", "public" ] }, + { symbol: [ "QtFbSupportDepends", "private", "", "public" ] }, + { symbol: [ "QtFbSupport", "private", "", "public" ] }, + { symbol: [ "QtEdidSupportDepends", "private", "", "public" ] }, + { symbol: [ "QtEdidSupportVersion", "private", "", "public" ] }, + { symbol: [ "QtEdidSupport", "private", "", "public" ] }, + { symbol: [ "QtDesignerComponentsDepends", "private", "", "public" ] }, + { symbol: [ "QtDesignerComponents", "private", "", "public" ] }, + { symbol: [ "QtDesignerComponentsVersion", "private", "", "public" ] }, + { symbol: [ "QtSerialPortDepends", "private", "", "public" ] }, + { symbol: [ "QSerialPortInfo", "private", "", "public" ] }, + { symbol: [ "QtSerialPort", "private", "", "public" ] }, + { symbol: [ "QtSerialPortVersion", "private", "", "public" ] }, + { symbol: [ "QSerialPort", "private", "", "public" ] }, + { symbol: [ "QtDeviceDiscoverySupportDepends", "private", "", "public" ] }, + { symbol: [ "QtDeviceDiscoverySupportVersion", "private", "", "public" ] }, + { symbol: [ "QtDeviceDiscoverySupport", "private", "", "public" ] }, + { symbol: [ "QDomNode", "private", "", "public" ] }, + { symbol: [ "QDomAttr", "private", "", "public" ] }, + { symbol: [ "QXmlDTDHandler", "private", "", "public" ] }, + { symbol: [ "QDomDocument", "private", "", "public" ] }, + { symbol: [ "QDomNodeList", "private", "", "public" ] }, + { symbol: [ "QDomNotation", "private", "", "public" ] }, + { symbol: [ "QDomProcessingInstruction", "private", "", "public" ] }, + { symbol: [ "QXmlContentHandler", "private", "", "public" ] }, + { symbol: [ "QDomImplementation", "private", "", "public" ] }, + { symbol: [ "QtXmlVersion", "private", "", "public" ] }, + { symbol: [ "QXmlLocator", "private", "", "public" ] }, + { symbol: [ "QDomComment", "private", "", "public" ] }, + { symbol: [ "QDomDocumentFragment", "private", "", "public" ] }, + { symbol: [ "QDomDocumentType", "private", "", "public" ] }, + { symbol: [ "QtXmlDepends", "private", "", "public" ] }, + { symbol: [ "QXmlAttributes", "private", "", "public" ] }, + { symbol: [ "QXmlEntityResolver", "private", "", "public" ] }, + { symbol: [ "QXmlErrorHandler", "private", "", "public" ] }, + { symbol: [ "QXmlSimpleReader", "private", "", "public" ] }, + { symbol: [ "QDomElement", "private", "", "public" ] }, + { symbol: [ "QXmlInputSource", "private", "", "public" ] }, + { symbol: [ "QDomCDATASection", "private", "", "public" ] }, + { symbol: [ "QDomEntityReference", "private", "", "public" ] }, + { symbol: [ "QtXml", "private", "", "public" ] }, + { symbol: [ "QDomEntity", "private", "", "public" ] }, + { symbol: [ "QXmlNamespaceSupport", "private", "", "public" ] }, + { symbol: [ "QXmlDefaultHandler", "private", "", "public" ] }, + { symbol: [ "QDomText", "private", "", "public" ] }, + { symbol: [ "QXmlDeclHandler", "private", "", "public" ] }, + { symbol: [ "QXmlParseException", "private", "", "public" ] }, + { symbol: [ "QXmlReader", "private", "", "public" ] }, + { symbol: [ "QDomCharacterData", "private", "", "public" ] }, + { symbol: [ "QXmlLexicalHandler", "private", "", "public" ] }, + { symbol: [ "QDomNamedNodeMap", "private", "", "public" ] }, + { symbol: [ "QtOpenGLExtensionsVersion", "private", "", "public" ] }, + { symbol: [ "QtOpenGLExtensionsDepends", "private", "", "public" ] }, + { symbol: [ "QOpenGLExtensions", "private", "", "public" ] }, + { symbol: [ "QtOpenGLExtensions", "private", "", "public" ] }, + { symbol: [ "QQmlTypesExtensionInterface", "private", "", "public" ] }, + { symbol: [ "QQmlScriptString", "private", "", "public" ] }, + { symbol: [ "QQmlPropertyMap", "private", "", "public" ] }, + { symbol: [ "QQmlError", "private", "", "public" ] }, + { symbol: [ "QQmlPropertyValueSource", "private", "", "public" ] }, + { symbol: [ "QQmlInfo", "private", "", "public" ] }, + { symbol: [ "QQmlProperty", "private", "", "public" ] }, + { symbol: [ "QQmlFileSelector", "private", "", "public" ] }, + { symbol: [ "QQmlTypeInfo", "private", "", "public" ] }, + { symbol: [ "QQmlAbstractUrlInterceptor", "private", "", "public" ] }, + { symbol: [ "QJSValueIterator", "private", "", "public" ] }, + { symbol: [ "QQmlDebuggingEnabler", "private", "", "public" ] }, + { symbol: [ "QQmlNetworkAccessManagerFactory", "private", "", "public" ] }, + { symbol: [ "QQmlAttachedPropertiesFunc", "private", "", "public" ] }, + { symbol: [ "QQmlComponent", "private", "", "public" ] }, + { symbol: [ "QJSValue", "private", "", "public" ] }, + { symbol: [ "QtQmlDepends", "private", "", "public" ] }, + { symbol: [ "QQmlParserStatus", "private", "", "public" ] }, + { symbol: [ "QQmlIncubator", "private", "", "public" ] }, + { symbol: [ "QQmlExtensionPlugin", "private", "", "public" ] }, + { symbol: [ "QQmlExpression", "private", "", "public" ] }, + { symbol: [ "QQmlExtensionInterface", "private", "", "public" ] }, + { symbol: [ "QQmlContext", "private", "", "public" ] }, + { symbol: [ "QJSValueList", "private", "", "public" ] }, + { symbol: [ "QQmlFile", "private", "", "public" ] }, + { symbol: [ "QJSEngine", "private", "", "public" ] }, + { symbol: [ "QtQmlVersion", "private", "", "public" ] }, + { symbol: [ "QQmlEngine", "private", "", "public" ] }, + { symbol: [ "QtQml", "private", "", "public" ] }, + { symbol: [ "QQmlProperties", "private", "", "public" ] }, + { symbol: [ "QQmlApplicationEngine", "private", "", "public" ] }, + { symbol: [ "QQmlListReference", "private", "", "public" ] }, + { symbol: [ "QQmlIncubationController", "private", "", "public" ] }, + { symbol: [ "QQmlListProperty", "private", "", "public" ] }, + { symbol: [ "QQmlImageProviderBase", "private", "", "public" ] }, + { symbol: [ "Qt3DQuickInputVersion", "private", "", "public" ] }, + { symbol: [ "Qt3DQuickInput", "private", "", "public" ] }, + { symbol: [ "Qt3DQuickInputDepends", "private", "", "public" ] }, + { symbol: [ "QWebHapticFeedbackPlayer", "private", "", "public" ] }, + { symbol: [ "QWebSettings", "private", "", "public" ] }, + { symbol: [ "QWebHistoryItem", "private", "", "public" ] }, + { symbol: [ "QWebDatabase", "private", "", "public" ] }, + { symbol: [ "QWebNotificationPresenter", "private", "", "public" ] }, + { symbol: [ "QWebSelectMethod", "private", "", "public" ] }, + { symbol: [ "QWebNotificationData", "private", "", "public" ] }, + { symbol: [ "QWebTouchModifier", "private", "", "public" ] }, + { symbol: [ "QtWebKitDepends", "private", "", "public" ] }, + { symbol: [ "QWebSecurityOrigin", "private", "", "public" ] }, + { symbol: [ "QWebSpellChecker", "private", "", "public" ] }, + { symbol: [ "QWebElement", "private", "", "public" ] }, + { symbol: [ "QWebSelectData", "private", "", "public" ] }, + { symbol: [ "QWebFullScreenVideoHandler", "private", "", "public" ] }, + { symbol: [ "QtWebKitVersion", "private", "", "public" ] }, + { symbol: [ "QWebHistory", "private", "", "public" ] }, + { symbol: [ "QWebHistoryInterface", "private", "", "public" ] }, + { symbol: [ "QWebFullScreenRequest", "private", "", "public" ] }, + { symbol: [ "QtWebKit", "private", "", "public" ] }, + { symbol: [ "QWebElementCollection", "private", "", "public" ] }, + { symbol: [ "QWebKitPlatformPlugin", "private", "", "public" ] }, + { symbol: [ "QWebPluginFactory", "private", "", "public" ] }, + { symbol: [ "QtFontDatabaseSupportDepends", "private", "", "public" ] }, + { symbol: [ "QtFontDatabaseSupportVersion", "private", "", "public" ] }, + { symbol: [ "QtFontDatabaseSupport", "private", "", "public" ] }, + { symbol: [ "QtX11ExtrasVersion", "private", "", "public" ] }, + { symbol: [ "QX11Info", "private", "", "public" ] }, + { symbol: [ "QtX11Extras", "private", "", "public" ] }, + { symbol: [ "QtX11ExtrasDepends", "private", "", "public" ] }, + { symbol: [ "QtConcurrentMap", "private", "", "public" ] }, + { symbol: [ "QtConcurrentRun", "private", "", "public" ] }, + { symbol: [ "QtConcurrentFilter", "private", "", "public" ] }, + { symbol: [ "QtConcurrentVersion", "private", "", "public" ] }, + { symbol: [ "QtConcurrentDepends", "private", "", "public" ] }, + { symbol: [ "QtConcurrent", "private", "", "public" ] }, + { symbol: [ "QHelpContentItem", "private", "", "public" ] }, + { symbol: [ "QHelpGlobal", "private", "", "public" ] }, + { symbol: [ "QtHelpDepends", "private", "", "public" ] }, + { symbol: [ "QHelpSearchQuery", "private", "", "public" ] }, + { symbol: [ "QHelpContentWidget", "private", "", "public" ] }, + { symbol: [ "QHelpSearchResultWidget", "private", "", "public" ] }, + { symbol: [ "QHelpSearchResult", "private", "", "public" ] }, + { symbol: [ "QHelpSearchQueryWidget", "private", "", "public" ] }, + { symbol: [ "QtHelpVersion", "private", "", "public" ] }, + { symbol: [ "QHelpIndexModel", "private", "", "public" ] }, + { symbol: [ "QHelpContentModel", "private", "", "public" ] }, + { symbol: [ "QHelpSearchEngine", "private", "", "public" ] }, + { symbol: [ "QtHelp", "private", "", "public" ] }, + { symbol: [ "QHelpIndexWidget", "private", "", "public" ] }, + { symbol: [ "QHelpEngineCore", "private", "", "public" ] }, + { symbol: [ "QHelpEngine", "private", "", "public" ] }, + { symbol: [ "QtUiToolsDepends", "private", "", "public" ] }, + { symbol: [ "QUiLoader", "private", "", "public" ] }, + { symbol: [ "QtUiToolsVersion", "private", "", "public" ] }, + { symbol: [ "QtUiTools", "private", "", "public" ] }, + { symbol: [ "QtEventDispatcherSupportVersion", "private", "", "public" ] }, + { symbol: [ "QtEventDispatcherSupportDepends", "private", "", "public" ] }, + { symbol: [ "QtEventDispatcherSupport", "private", "", "public" ] }, + { symbol: [ "QXmlStreamWriter", "private", "", "public" ] }, + { symbol: [ "QTime", "private", "", "public" ] }, + { symbol: [ "QObjectList", "private", "", "public" ] }, + { symbol: [ "QFileSelector", "private", "", "public" ] }, + { symbol: [ "QSequentialIterable", "private", "", "public" ] }, + { symbol: [ "QAtomicInt", "private", "", "public" ] }, + { symbol: [ "QDate", "private", "", "public" ] }, + { symbol: [ "QList", "private", "", "public" ] }, + { symbol: [ "QQueue", "private", "", "public" ] }, + { symbol: [ "QTranslator", "private", "", "public" ] }, + { symbol: [ "QByteArrayDataPtr", "private", "", "public" ] }, + { symbol: [ "QStringLiteral", "private", "", "public" ] }, + { symbol: [ "QXmlStreamAttributes", "private", "", "public" ] }, + { symbol: [ "QParallelAnimationGroup", "private", "", "public" ] }, + { symbol: [ "QPropertyAnimation", "private", "", "public" ] }, + { symbol: [ "QSet", "private", "", "public" ] }, + { symbol: [ "QContiguousCacheTypedData", "private", "", "public" ] }, + { symbol: [ "QtContainerFwd", "private", "", "public" ] }, + { symbol: [ "QLinkedList", "private", "", "public" ] }, + { symbol: [ "QMimeData", "private", "", "public" ] }, + { symbol: [ "QByteRef", "private", "", "public" ] }, + { symbol: [ "QSaveFile", "private", "", "public" ] }, + { symbol: [ "QTemporaryDir", "private", "", "public" ] }, + { symbol: [ "QStringRef", "private", "", "public" ] }, + { symbol: [ "QLinkedListData", "private", "", "public" ] }, + { symbol: [ "QWriteLocker", "private", "", "public" ] }, + { symbol: [ "QSetIterator", "private", "", "public" ] }, + { symbol: [ "QXmlStreamStringRef", "private", "", "public" ] }, + { symbol: [ "QLinkedListNode", "private", "", "public" ] }, + { symbol: [ "QMimeDatabase", "private", "", "public" ] }, + { symbol: [ "QFutureSynchronizer", "private", "", "public" ] }, + { symbol: [ "QFinalState", "private", "", "public" ] }, + { symbol: [ "QAbstractNativeEventFilter", "private", "", "public" ] }, + { symbol: [ "QTimeZone", "private", "", "public" ] }, + { symbol: [ "QtGlobal", "private", "", "public" ] }, + { symbol: [ "QScopedPointerDeleter", "private", "", "public" ] }, + { symbol: [ "QPointF", "private", "", "public" ] }, + { symbol: [ "QByteArrayData", "private", "", "public" ] }, + { symbol: [ "QNonConstOverload", "private", "", "public" ] }, + { symbol: [ "QSysInfo", "private", "", "public" ] }, + { symbol: [ "QStringList", "private", "", "public" ] }, + { symbol: [ "QXmlStreamNotationDeclaration", "private", "", "public" ] }, + { symbol: [ "QFutureWatcher", "private", "", "public" ] }, + { symbol: [ "QScopedValueRollback", "private", "", "public" ] }, + { symbol: [ "QXmlStreamReader", "private", "", "public" ] }, + { symbol: [ "QAbstractState", "private", "", "public" ] }, + { symbol: [ "QCollatorSortKey", "private", "", "public" ] }, + { symbol: [ "QUuid", "private", "", "public" ] }, + { symbol: [ "QFutureInterface", "private", "", "public" ] }, + { symbol: [ "QtDebug", "private", "", "public" ] }, + { symbol: [ "QAbstractTransition", "private", "", "public" ] }, + { symbol: [ "QTimer", "private", "", "public" ] }, + { symbol: [ "QTypeInfo", "private", "", "public" ] }, + { symbol: [ "QItemSelection", "private", "", "public" ] }, + { symbol: [ "QMessageLogger", "private", "", "public" ] }, + { symbol: [ "QRegExp", "private", "", "public" ] }, + { symbol: [ "QCoreApplication", "private", "", "public" ] }, + { symbol: [ "QStack", "private", "", "public" ] }, + { symbol: [ "QBEInteger", "private", "", "public" ] }, + { symbol: [ "QBuffer", "private", "", "public" ] }, + { symbol: [ "QtPluginMetaDataFunction", "private", "", "public" ] }, + { symbol: [ "QFutureIterator", "private", "", "public" ] }, + { symbol: [ "Q_STARTUPINFO", "private", "", "public" ] }, + { symbol: [ "QSpecialInteger", "private", "", "public" ] }, + { symbol: [ "QLatin1Char", "private", "", "public" ] }, + { symbol: [ "QMetaProperty", "private", "", "public" ] }, + { symbol: [ "QSignalBlocker", "private", "", "public" ] }, + { symbol: [ "QProcessEnvironment", "private", "", "public" ] }, + { symbol: [ "QStaticStringData", "private", "", "public" ] }, + { symbol: [ "QLine", "private", "", "public" ] }, + { symbol: [ "QTimeLine", "private", "", "public" ] }, + { symbol: [ "QAtomicPointer", "private", "", "public" ] }, + { symbol: [ "QAtomicInteger", "private", "", "public" ] }, + { symbol: [ "QMutableVectorIterator", "private", "", "public" ] }, + { symbol: [ "QXmlStreamNamespaceDeclarations", "private", "", "public" ] }, + { symbol: [ "QSize", "private", "", "public" ] }, + { symbol: [ "QIntegerForSize", "private", "", "public" ] }, + { symbol: [ "QtPluginInstanceFunction", "private", "", "public" ] }, + { symbol: [ "QArrayDataPointerRef", "private", "", "public" ] }, + { symbol: [ "Qt", "private", "", "public" ] }, + { symbol: [ "QScopedPointerDeleteLater", "private", "", "public" ] }, + { symbol: [ "QSharedData", "private", "", "public" ] }, + { symbol: [ "QLoggingCategory", "private", "", "public" ] }, + { symbol: [ "QFileInfo", "private", "", "public" ] }, + { symbol: [ "QByteArray", "private", "", "public" ] }, + { symbol: [ "QSignalTransition", "private", "", "public" ] }, + { symbol: [ "QBigEndianStorageType", "private", "", "public" ] }, + { symbol: [ "QLineF", "private", "", "public" ] }, + { symbol: [ "QLittleEndianStorageType", "private", "", "public" ] }, + { symbol: [ "QEasingCurve", "private", "", "public" ] }, + { symbol: [ "QLinkedListIterator", "private", "", "public" ] }, + { symbol: [ "QStaticByteArrayData", "private", "", "public" ] }, + { symbol: [ "QMargins", "private", "", "public" ] }, + { symbol: [ "QStateMachine", "private", "", "public" ] }, + { symbol: [ "QScopedPointerObjectDeleteLater", "private", "", "public" ] }, + { symbol: [ "QTextCodec", "private", "", "public" ] }, + { symbol: [ "QUrl", "private", "", "public" ] }, + { symbol: [ "QFactoryInterface", "private", "", "public" ] }, + { symbol: [ "QAbstractTableModel", "private", "", "public" ] }, + { symbol: [ "QFileDevice", "private", "", "public" ] }, + { symbol: [ "QPair", "private", "", "public" ] }, + { symbol: [ "QJsonArray", "private", "", "public" ] }, + { symbol: [ "Q_PID", "private", "", "public" ] }, + { symbol: [ "QtPlugin", "private", "", "public" ] }, + { symbol: [ "QMultiMap", "private", "", "public" ] }, + { symbol: [ "QJsonValueRef", "private", "", "public" ] }, + { symbol: [ "QIncompatibleFlag", "private", "", "public" ] }, + { symbol: [ "QBitArray", "private", "", "public" ] }, + { symbol: [ "QMapNode", "private", "", "public" ] }, + { symbol: [ "QObjectUserData", "private", "", "public" ] }, + { symbol: [ "QArrayDataPointer", "private", "", "public" ] }, + { symbol: [ "QFlags", "private", "", "public" ] }, + { symbol: [ "QVariantMap", "private", "", "public" ] }, + { symbol: [ "QThreadPool", "private", "", "public" ] }, + { symbol: [ "QElapsedTimer", "private", "", "public" ] }, + { symbol: [ "QtEndian", "private", "", "public" ] }, + { symbol: [ "QTextEncoder", "private", "", "public" ] }, + { symbol: [ "QException", "private", "", "public" ] }, + { symbol: [ "QMapDataBase", "private", "", "public" ] }, + { symbol: [ "QMetaClassInfo", "private", "", "public" ] }, + { symbol: [ "QLocale", "private", "", "public" ] }, + { symbol: [ "QMapNodeBase", "private", "", "public" ] }, + { symbol: [ "QScopedPointerArrayDeleter", "private", "", "public" ] }, + { symbol: [ "QBasicTimer", "private", "", "public" ] }, + { symbol: [ "QDateTime", "private", "", "public" ] }, + { symbol: [ "QStaticArrayData", "private", "", "public" ] }, + { symbol: [ "QLEInteger", "private", "", "public" ] }, + { symbol: [ "QVariantAnimation", "private", "", "public" ] }, + { symbol: [ "QFutureWatcherBase", "private", "", "public" ] }, + { symbol: [ "QFuture", "private", "", "public" ] }, + { symbol: [ "QByteArrayList", "private", "", "public" ] }, + { symbol: [ "QMutableFutureIterator", "private", "", "public" ] }, + { symbol: [ "QVersionNumber", "private", "", "public" ] }, + { symbol: [ "QCharRef", "private", "", "public" ] }, + { symbol: [ "QTextDecoder", "private", "", "public" ] }, + { symbol: [ "QListIterator", "private", "", "public" ] }, + { symbol: [ "QTextStream", "private", "", "public" ] }, + { symbol: [ "QObjectCleanupHandler", "private", "", "public" ] }, + { symbol: [ "QPoint", "private", "", "public" ] }, + { symbol: [ "QReadWriteLock", "private", "", "public" ] }, + { symbol: [ "QAssociativeIterable", "private", "", "public" ] }, + { symbol: [ "QRandomGenerator", "private", "", "public" ] }, + { symbol: [ "QString", "private", "", "public" ] }, + { symbol: [ "QtMessageHandler", "private", "", "public" ] }, + { symbol: [ "QJsonValue", "private", "", "public" ] }, + { symbol: [ "QEvent", "private", "", "public" ] }, + { symbol: [ "QReadLocker", "private", "", "public" ] }, + { symbol: [ "QSharedDataPointer", "private", "", "public" ] }, + { symbol: [ "QtCoreDepends", "private", "", "public" ] }, + { symbol: [ "QMutableStringListIterator", "private", "", "public" ] }, + { symbol: [ "QDirIterator", "private", "", "public" ] }, + { symbol: [ "QtCleanUpFunction", "private", "", "public" ] }, + { symbol: [ "QtMsgHandler", "private", "", "public" ] }, + { symbol: [ "QAbstractProxyModel", "private", "", "public" ] }, + { symbol: [ "QtCoreVersion", "private", "", "public" ] }, + { symbol: [ "QStorageInfo", "private", "", "public" ] }, + { symbol: [ "QStaticPlugin", "private", "", "public" ] }, + { symbol: [ "QState", "private", "", "public" ] }, + { symbol: [ "QLibraryInfo", "private", "", "public" ] }, + { symbol: [ "QSignalMapper", "private", "", "public" ] }, + { symbol: [ "QTypeInfoMerger", "private", "", "public" ] }, + { symbol: [ "QHashFunctions", "private", "", "public" ] }, + { symbol: [ "QContiguousCache", "private", "", "public" ] }, + { symbol: [ "QRandomGenerator64", "private", "", "public" ] }, + { symbol: [ "QHashNode", "private", "", "public" ] }, + { symbol: [ "QRectF", "private", "", "public" ] }, + { symbol: [ "QLibrary", "private", "", "public" ] }, + { symbol: [ "QNoDebug", "private", "", "public" ] }, + { symbol: [ "QContiguousCacheData", "private", "", "public" ] }, + { symbol: [ "QSequentialAnimationGroup", "private", "", "public" ] }, + { symbol: [ "QIdentityProxyModel", "private", "", "public" ] }, + { symbol: [ "QScopedPointerPodDeleter", "private", "", "public" ] }, + { symbol: [ "QTextStreamFunction", "private", "", "public" ] }, + { symbol: [ "QItemSelectionModel", "private", "", "public" ] }, + { symbol: [ "QMarginsF", "private", "", "public" ] }, + { symbol: [ "QXmlStreamEntityDeclarations", "private", "", "public" ] }, + { symbol: [ "QEventLoop", "private", "", "public" ] }, + { symbol: [ "QtConfig", "private", "", "public" ] }, + { symbol: [ "QJsonValuePtr", "private", "", "public" ] }, + { symbol: [ "QThread", "private", "", "public" ] }, + { symbol: [ "QChildEvent", "private", "", "public" ] }, + { symbol: [ "QCollator", "private", "", "public" ] }, + { symbol: [ "QMutableLinkedListIterator", "private", "", "public" ] }, + { symbol: [ "QHashDummyValue", "private", "", "public" ] }, + { symbol: [ "QMimeType", "private", "", "public" ] }, + { symbol: [ "QtAlgorithms", "private", "", "public" ] }, + { symbol: [ "QItemSelectionRange", "private", "", "public" ] }, + { symbol: [ "QMetaType", "private", "", "public" ] }, + { symbol: [ "QStringAlgorithms", "private", "", "public" ] }, + { symbol: [ "QStandardPaths", "private", "", "public" ] }, + { symbol: [ "QSemaphoreReleaser", "private", "", "public" ] }, + { symbol: [ "QRunnable", "private", "", "public" ] }, + { symbol: [ "QDataStream", "private", "", "public" ] }, + { symbol: [ "QModelIndexList", "private", "", "public" ] }, + { symbol: [ "QSharedPointer", "private", "", "public" ] }, + { symbol: [ "QVarLengthArray", "private", "", "public" ] }, + { symbol: [ "QAbstractEventDispatcher", "private", "", "public" ] }, + { symbol: [ "QWaitCondition", "private", "", "public" ] }, + { symbol: [ "QGlobalStatic", "private", "", "public" ] }, + { symbol: [ "QMutableByteArrayListIterator", "private", "", "public" ] }, + { symbol: [ "QListData", "private", "", "public" ] }, + { symbol: [ "QMapData", "private", "", "public" ] }, + { symbol: [ "QFile", "private", "", "public" ] }, + { symbol: [ "QCommandLineOption", "private", "", "public" ] }, + { symbol: [ "QXmlStreamNamespaceDeclaration", "private", "", "public" ] }, + { symbol: [ "QByteArrayListIterator", "private", "", "public" ] }, + { symbol: [ "QAnimationGroup", "private", "", "public" ] }, + { symbol: [ "QPersistentModelIndex", "private", "", "public" ] }, + { symbol: [ "QStringDataPtr", "private", "", "public" ] }, + { symbol: [ "QStringView", "private", "", "public" ] }, + { symbol: [ "QMetaEnum", "private", "", "public" ] }, + { symbol: [ "QMutableMapIterator", "private", "", "public" ] }, + { symbol: [ "QStringListModel", "private", "", "public" ] }, + { symbol: [ "QObject", "private", "", "public" ] }, + { symbol: [ "QAbstractListModel", "private", "", "public" ] }, + { symbol: [ "QPluginLoader", "private", "", "public" ] }, + { symbol: [ "QMutableSetIterator", "private", "", "public" ] }, + { symbol: [ "QLockFile", "private", "", "public" ] }, + { symbol: [ "QDeferredDeleteEvent", "private", "", "public" ] }, + { symbol: [ "QXmlStreamEntityResolver", "private", "", "public" ] }, + { symbol: [ "QChar", "private", "", "public" ] }, + { symbol: [ "QDebug", "private", "", "public" ] }, + { symbol: [ "QDynamicPropertyChangeEvent", "private", "", "public" ] }, + { symbol: [ "QMetaMethod", "private", "", "public" ] }, + { symbol: [ "QCommandLineParser", "private", "", "public" ] }, + { symbol: [ "QSemaphore", "private", "", "public" ] }, + { symbol: [ "QFutureInterfaceBase", "private", "", "public" ] }, + { symbol: [ "QSharedMemory", "private", "", "public" ] }, + { symbol: [ "QBasicMutex", "private", "", "public" ] }, + { symbol: [ "QPauseAnimation", "private", "", "public" ] }, + { symbol: [ "QEventLoopLocker", "private", "", "public" ] }, + { symbol: [ "QDeadlineTimer", "private", "", "public" ] }, + { symbol: [ "QLatin1Literal", "private", "", "public" ] }, + { symbol: [ "QUrlQuery", "private", "", "public" ] }, + { symbol: [ "QByteArrayMatcher", "private", "", "public" ] }, + { symbol: [ "QSizeF", "private", "", "public" ] }, + { symbol: [ "QDir", "private", "", "public" ] }, + { symbol: [ "QJsonObject", "private", "", "public" ] }, + { symbol: [ "QKeyValueIterator", "private", "", "public" ] }, + { symbol: [ "QJsonDocument", "private", "", "public" ] }, + { symbol: [ "QArgument", "private", "", "public" ] }, + { symbol: [ "QRegularExpression", "private", "", "public" ] }, + { symbol: [ "QEnableSharedFromThis", "private", "", "public" ] }, + { symbol: [ "QResource", "private", "", "public" ] }, + { symbol: [ "QMap", "private", "", "public" ] }, + { symbol: [ "QFlag", "private", "", "public" ] }, + { symbol: [ "QProcess", "private", "", "public" ] }, + { symbol: [ "QConstOverload", "private", "", "public" ] }, + { symbol: [ "QStringMatcher", "private", "", "public" ] }, + { symbol: [ "QXmlStreamNotationDeclarations", "private", "", "public" ] }, + { symbol: [ "QFileInfoList", "private", "", "public" ] }, + { symbol: [ "QMutex", "private", "", "public" ] }, + { symbol: [ "QWinEventNotifier", "private", "", "public" ] }, + { symbol: [ "QUrlTwoFlags", "private", "", "public" ] }, + { symbol: [ "QAbstractItemModel", "private", "", "public" ] }, + { symbol: [ "QMutableHashIterator", "private", "", "public" ] }, + { symbol: [ "QTemporaryFile", "private", "", "public" ] }, + { symbol: [ "QSortFilterProxyModel", "private", "", "public" ] }, + { symbol: [ "QSettings", "private", "", "public" ] }, + { symbol: [ "QThreadStorageData", "private", "", "public" ] }, + { symbol: [ "QInternal", "private", "", "public" ] }, + { symbol: [ "QPointer", "private", "", "public" ] }, + { symbol: [ "QAnimationDriver", "private", "", "public" ] }, + { symbol: [ "QFunctionPointer", "private", "", "public" ] }, + { symbol: [ "QRegularExpressionMatchIterator", "private", "", "public" ] }, + { symbol: [ "QMutableListIterator", "private", "", "public" ] }, + { symbol: [ "QDebugStateSaver", "private", "", "public" ] }, + { symbol: [ "QVariantList", "private", "", "public" ] }, + { symbol: [ "QStaticByteArrayMatcherBase", "private", "", "public" ] }, + { symbol: [ "QXmlStreamAttribute", "private", "", "public" ] }, + { symbol: [ "QBitRef", "private", "", "public" ] }, + { symbol: [ "QHashData", "private", "", "public" ] }, + { symbol: [ "QRect", "private", "", "public" ] }, + { symbol: [ "QtCore", "private", "", "public" ] }, + { symbol: [ "QTextBoundaryFinder", "private", "", "public" ] }, + { symbol: [ "QTimerEvent", "private", "", "public" ] }, + { symbol: [ "QTextStreamManipulator", "private", "", "public" ] }, + { symbol: [ "QListSpecialMethods", "private", "", "public" ] }, + { symbol: [ "QMapIterator", "private", "", "public" ] }, + { symbol: [ "QTypeInfoQuery", "private", "", "public" ] }, + { symbol: [ "QFloat16", "private", "", "public" ] }, + { symbol: [ "QArrayData", "private", "", "public" ] }, + { symbol: [ "QThreadStorage", "private", "", "public" ] }, + { symbol: [ "QStringListIterator", "private", "", "public" ] }, + { symbol: [ "QVariant", "private", "", "public" ] }, + { symbol: [ "QMutexLocker", "private", "", "public" ] }, + { symbol: [ "QOperatingSystemVersion", "private", "", "public" ] }, + { symbol: [ "QMessageAuthenticationCode", "private", "", "public" ] }, + { symbol: [ "QMetaObject", "private", "", "public" ] }, + { symbol: [ "QJsonParseError", "private", "", "public" ] }, + { symbol: [ "QMessageLogContext", "private", "", "public" ] }, + { symbol: [ "QLatin1String", "private", "", "public" ] }, + { symbol: [ "QObjectData", "private", "", "public" ] }, + { symbol: [ "QStringData", "private", "", "public" ] }, + { symbol: [ "QtNumeric", "private", "", "public" ] }, + { symbol: [ "QUnhandledException", "private", "", "public" ] }, + { symbol: [ "QVectorIterator", "private", "", "public" ] }, + { symbol: [ "QScopedPointer", "private", "", "public" ] }, + { symbol: [ "QXmlStreamEntityDeclaration", "private", "", "public" ] }, + { symbol: [ "QSocketNotifier", "private", "", "public" ] }, + { symbol: [ "QModelIndex", "private", "", "public" ] }, + { symbol: [ "QJsonValueRefPtr", "private", "", "public" ] }, + { symbol: [ "QEventTransition", "private", "", "public" ] }, + { symbol: [ "QVariantComparisonHelper", "private", "", "public" ] }, + { symbol: [ "QReturnArgument", "private", "", "public" ] }, + { symbol: [ "QScopedArrayPointer", "private", "", "public" ] }, + { symbol: [ "QWeakPointer", "private", "", "public" ] }, + { symbol: [ "QStringBuilder", "private", "", "public" ] }, + { symbol: [ "QAbstractAnimation", "private", "", "public" ] }, + { symbol: [ "QHashIterator", "private", "", "public" ] }, + { symbol: [ "QCache", "private", "", "public" ] }, + { symbol: [ "QGenericReturnArgument", "private", "", "public" ] }, + { symbol: [ "QFileSystemWatcher", "private", "", "public" ] }, + { symbol: [ "QExplicitlySharedDataPointer", "private", "", "public" ] }, + { symbol: [ "QVector", "private", "", "public" ] }, + { symbol: [ "QHistoryState", "private", "", "public" ] }, + { symbol: [ "QIODevice", "private", "", "public" ] }, + { symbol: [ "Q_SECURITY_ATTRIBUTES", "private", "", "public" ] }, + { symbol: [ "QSystemSemaphore", "private", "", "public" ] }, + { symbol: [ "QGenericArgument", "private", "", "public" ] }, + { symbol: [ "QtPacketProtocolDepends", "private", "", "public" ] }, + { symbol: [ "QtPacketProtocolVersion", "private", "", "public" ] }, + { symbol: [ "QtPacketProtocol", "private", "", "public" ] }, + { symbol: [ "QtLinuxAccessibilitySupportVersion", "private", "", "public" ] }, + { symbol: [ "QtLinuxAccessibilitySupport", "private", "", "public" ] }, + { symbol: [ "QtLinuxAccessibilitySupportDepends", "private", "", "public" ] }, + { symbol: [ "QGLFramebufferObjectFormat", "private", "", "public" ] }, + { symbol: [ "QGLFramebufferObject", "private", "", "public" ] }, + { symbol: [ "QGLWidget", "private", "", "public" ] }, + { symbol: [ "QGLFunctionsPrivate", "private", "", "public" ] }, + { symbol: [ "QGLPixelBuffer", "private", "", "public" ] }, + { symbol: [ "QtOpenGLVersion", "private", "", "public" ] }, + { symbol: [ "QGLBuffer", "private", "", "public" ] }, + { symbol: [ "QGLColormap", "private", "", "public" ] }, + { symbol: [ "QGLShader", "private", "", "public" ] }, + { symbol: [ "QGLShaderProgram", "private", "", "public" ] }, + { symbol: [ "QGLContext", "private", "", "public" ] }, + { symbol: [ "QGL", "private", "", "public" ] }, + { symbol: [ "QtOpenGL", "private", "", "public" ] }, + { symbol: [ "QtOpenGLDepends", "private", "", "public" ] }, + { symbol: [ "QGLFunctions", "private", "", "public" ] }, + { symbol: [ "QGLFormat", "private", "", "public" ] }, + { symbol: [ "Qt3DInputVersion", "private", "", "public" ] }, + { symbol: [ "QMouseHandler", "private", "", "public" ] }, + { symbol: [ "QPhysicalDeviceCreatedChangeBasePtr", "private", "", "public" ] }, + { symbol: [ "Qt3DInputDepends", "private", "", "public" ] }, + { symbol: [ "QAxis", "private", "", "public" ] }, + { symbol: [ "QMouseEvent", "private", "", "public" ] }, + { symbol: [ "QLogicalDevice", "private", "", "public" ] }, + { symbol: [ "QActionInput", "private", "", "public" ] }, + { symbol: [ "QKeyboardDevice", "private", "", "public" ] }, + { symbol: [ "QWheelEventPtr", "private", "", "public" ] }, + { symbol: [ "QKeyEvent", "private", "", "public" ] }, + { symbol: [ "QAbstractActionInput", "private", "", "public" ] }, + { symbol: [ "QKeyEventPtr", "private", "", "public" ] }, + { symbol: [ "QAction", "private", "", "public" ] }, + { symbol: [ "QMouseEventPtr", "private", "", "public" ] }, + { symbol: [ "QInputAspect", "private", "", "public" ] }, + { symbol: [ "QInputChord", "private", "", "public" ] }, + { symbol: [ "QPhysicalDeviceCreatedChange", "private", "", "public" ] }, + { symbol: [ "QAnalogAxisInput", "private", "", "public" ] }, + { symbol: [ "QAxisSetting", "private", "", "public" ] }, + { symbol: [ "QMouseDevice", "private", "", "public" ] }, + { symbol: [ "QAbstractAxisInput", "private", "", "public" ] }, + { symbol: [ "QWheelEvent", "private", "", "public" ] }, + { symbol: [ "QPhysicalDeviceCreatedChangeBase", "private", "", "public" ] }, + { symbol: [ "QButtonAxisInput", "private", "", "public" ] }, + { symbol: [ "QInputSequence", "private", "", "public" ] }, + { symbol: [ "QInputSettings", "private", "", "public" ] }, + { symbol: [ "Qt3DInput", "private", "", "public" ] }, + { symbol: [ "QAbstractPhysicalDevice", "private", "", "public" ] }, + { symbol: [ "QAxisAccumulator", "private", "", "public" ] }, + { symbol: [ "QKeyboardHandler", "private", "", "public" ] }, + { symbol: [ "QtServiceSupportVersion", "private", "", "public" ] }, + { symbol: [ "QtServiceSupportDepends", "private", "", "public" ] }, + { symbol: [ "QtServiceSupport", "private", "", "public" ] }, + { symbol: [ "QIntegrityHIDManager", "private", "", "public" ] }, + { symbol: [ "QtInputSupportDepends", "private", "", "public" ] }, + { symbol: [ "QtInputSupport", "private", "", "public" ] }, + { symbol: [ "QtInputSupportVersion", "private", "", "public" ] }, + { symbol: [ "QtVulkanSupportDepends", "private", "", "public" ] }, + { symbol: [ "QtVulkanSupport", "private", "", "public" ] }, + { symbol: [ "QtVulkanSupportVersion", "private", "", "public" ] }, + { symbol: [ "QSystemTrayIcon", "private", "", "public" ] }, + { symbol: [ "QStyleOptionGraphicsItem", "private", "", "public" ] }, + { symbol: [ "QDirModel", "private", "", "public" ] }, + { symbol: [ "QTapGesture", "private", "", "public" ] }, + { symbol: [ "QTileRules", "private", "", "public" ] }, + { symbol: [ "QTextEdit", "private", "", "public" ] }, + { symbol: [ "QStyleOptionToolBox", "private", "", "public" ] }, + { symbol: [ "QKeyEventTransition", "private", "", "public" ] }, + { symbol: [ "QGridLayout", "private", "", "public" ] }, + { symbol: [ "QGraphicsSceneHoverEvent", "private", "", "public" ] }, + { symbol: [ "QColumnView", "private", "", "public" ] }, + { symbol: [ "QGraphicsBlurEffect", "private", "", "public" ] }, + { symbol: [ "QShortcut", "private", "", "public" ] }, + { symbol: [ "QGraphicsWidget", "private", "", "public" ] }, + { symbol: [ "QGesture", "private", "", "public" ] }, + { symbol: [ "QStyleOptionViewItemV4", "private", "", "public" ] }, + { symbol: [ "QItemDelegate", "private", "", "public" ] }, + { symbol: [ "QGraphicsColorizeEffect", "private", "", "public" ] }, + { symbol: [ "QSizePolicy", "private", "", "public" ] }, + { symbol: [ "QStyleFactory", "private", "", "public" ] }, + { symbol: [ "QListWidget", "private", "", "public" ] }, + { symbol: [ "QGraphicsSceneMoveEvent", "private", "", "public" ] }, + { symbol: [ "QGraphicsRotation", "private", "", "public" ] }, + { symbol: [ "QAbstractSlider", "private", "", "public" ] }, + { symbol: [ "QStyleOptionRubberBand", "private", "", "public" ] }, + { symbol: [ "QFontComboBox", "private", "", "public" ] }, + { symbol: [ "QKeySequenceEdit", "private", "", "public" ] }, + { symbol: [ "QFrame", "private", "", "public" ] }, + { symbol: [ "QGraphicsItemGroup", "private", "", "public" ] }, + { symbol: [ "QListWidgetItem", "private", "", "public" ] }, + { symbol: [ "QGraphicsPathItem", "private", "", "public" ] }, + { symbol: [ "QStyleOptionProgressBarV2", "private", "", "public" ] }, + { symbol: [ "QSplashScreen", "private", "", "public" ] }, + { symbol: [ "QGraphicsEffect", "private", "", "public" ] }, + { symbol: [ "QGraphicsSimpleTextItem", "private", "", "public" ] }, + { symbol: [ "QGraphicsSceneEvent", "private", "", "public" ] }, + { symbol: [ "QScrollerProperties", "private", "", "public" ] }, + { symbol: [ "QStyleOptionTabWidgetFrame", "private", "", "public" ] }, + { symbol: [ "QStyleOptionTabWidgetFrameV2", "private", "", "public" ] }, + { symbol: [ "QAbstractButton", "private", "", "public" ] }, + { symbol: [ "QTabWidget", "private", "", "public" ] }, + { symbol: [ "QTreeWidgetItem", "private", "", "public" ] }, + { symbol: [ "QtWidgetsDepends", "private", "", "public" ] }, + { symbol: [ "QComboBox", "private", "", "public" ] }, + { symbol: [ "QDoubleSpinBox", "private", "", "public" ] }, + { symbol: [ "QStyleOptionGroupBox", "private", "", "public" ] }, + { symbol: [ "QSizeGrip", "private", "", "public" ] }, + { symbol: [ "QTabBar", "private", "", "public" ] }, + { symbol: [ "QGroupBox", "private", "", "public" ] }, + { symbol: [ "QMenuBar", "private", "", "public" ] }, + { symbol: [ "QFormLayout", "private", "", "public" ] }, + { symbol: [ "QMessageBox", "private", "", "public" ] }, + { symbol: [ "QWhatsThis", "private", "", "public" ] }, + { symbol: [ "QGraphicsPixmapItem", "private", "", "public" ] }, + { symbol: [ "QGraphicsSceneContextMenuEvent", "private", "", "public" ] }, + { symbol: [ "QStyleOptionViewItemV3", "private", "", "public" ] }, + { symbol: [ "QLCDNumber", "private", "", "public" ] }, + { symbol: [ "QApplication", "private", "", "public" ] }, + { symbol: [ "QStyleOptionTabV3", "private", "", "public" ] }, + { symbol: [ "QWizardPage", "private", "", "public" ] }, + { symbol: [ "QAbstractGraphicsShapeItem", "private", "", "public" ] }, + { symbol: [ "QStyleOptionSizeGrip", "private", "", "public" ] }, + { symbol: [ "QGestureEvent", "private", "", "public" ] }, + { symbol: [ "QSlider", "private", "", "public" ] }, + { symbol: [ "QRubberBand", "private", "", "public" ] }, + { symbol: [ "QLayoutItem", "private", "", "public" ] }, + { symbol: [ "QSplitterHandle", "private", "", "public" ] }, + { symbol: [ "QAbstractItemDelegate", "private", "", "public" ] }, + { symbol: [ "QUndoView", "private", "", "public" ] }, + { symbol: [ "QMacNativeWidget", "private", "", "public" ] }, + { symbol: [ "QWidget", "private", "", "public" ] }, + { symbol: [ "QGraphicsScene", "private", "", "public" ] }, + { symbol: [ "QButtonGroup", "private", "", "public" ] }, + { symbol: [ "QToolBar", "private", "", "public" ] }, + { symbol: [ "QMacCocoaViewContainer", "private", "", "public" ] }, + { symbol: [ "QDateEdit", "private", "", "public" ] }, + { symbol: [ "QStyleOptionTab", "private", "", "public" ] }, + { symbol: [ "QDial", "private", "", "public" ] }, + { symbol: [ "QPlainTextEdit", "private", "", "public" ] }, + { symbol: [ "QGraphicsObject", "private", "", "public" ] }, + { symbol: [ "QTableView", "private", "", "public" ] }, + { symbol: [ "QTapAndHoldGesture", "private", "", "public" ] }, + { symbol: [ "QMdiArea", "private", "", "public" ] }, + { symbol: [ "QGraphicsSceneResizeEvent", "private", "", "public" ] }, + { symbol: [ "QHeaderView", "private", "", "public" ] }, + { symbol: [ "QDataWidgetMapper", "private", "", "public" ] }, + { symbol: [ "QCommonStyle", "private", "", "public" ] }, + { symbol: [ "QStyleOptionDockWidget", "private", "", "public" ] }, + { symbol: [ "QItemEditorFactory", "private", "", "public" ] }, + { symbol: [ "QDesktopWidget", "private", "", "public" ] }, + { symbol: [ "QWidgetAction", "private", "", "public" ] }, + { symbol: [ "QStyleOptionProgressBar", "private", "", "public" ] }, + { symbol: [ "QStyleOptionComboBox", "private", "", "public" ] }, + { symbol: [ "QTimeEdit", "private", "", "public" ] }, + { symbol: [ "QActionGroup", "private", "", "public" ] }, + { symbol: [ "QLabel", "private", "", "public" ] }, + { symbol: [ "QUndoCommand", "private", "", "public" ] }, + { symbol: [ "QWidgetItem", "private", "", "public" ] }, + { symbol: [ "QStyleOptionDockWidgetV2", "private", "", "public" ] }, + { symbol: [ "QStackedLayout", "private", "", "public" ] }, + { symbol: [ "QGestureRecognizer", "private", "", "public" ] }, + { symbol: [ "QBoxLayout", "private", "", "public" ] }, + { symbol: [ "QGraphicsDropShadowEffect", "private", "", "public" ] }, + { symbol: [ "QItemEditorCreatorBase", "private", "", "public" ] }, + { symbol: [ "QtWidgetsVersion", "private", "", "public" ] }, + { symbol: [ "QStylePainter", "private", "", "public" ] }, + { symbol: [ "QGraphicsPolygonItem", "private", "", "public" ] }, + { symbol: [ "QToolButton", "private", "", "public" ] }, + { symbol: [ "QErrorMessage", "private", "", "public" ] }, + { symbol: [ "QDockWidget", "private", "", "public" ] }, + { symbol: [ "QAction", "private", "", "public" ] }, + { symbol: [ "QGraphicsSceneWheelEvent", "private", "", "public" ] }, + { symbol: [ "QStyleOption", "private", "", "public" ] }, + { symbol: [ "QMdiSubWindow", "private", "", "public" ] }, + { symbol: [ "QPanGesture", "private", "", "public" ] }, + { symbol: [ "QDateTimeEdit", "private", "", "public" ] }, + { symbol: [ "QStyleOptionTabBarBaseV2", "private", "", "public" ] }, + { symbol: [ "QStyleOptionHeader", "private", "", "public" ] }, + { symbol: [ "QGraphicsRectItem", "private", "", "public" ] }, + { symbol: [ "QSplitter", "private", "", "public" ] }, + { symbol: [ "QRadioButton", "private", "", "public" ] }, + { symbol: [ "QGraphicsTextItem", "private", "", "public" ] }, + { symbol: [ "QCheckBox", "private", "", "public" ] }, + { symbol: [ "QTableWidgetSelectionRange", "private", "", "public" ] }, + { symbol: [ "QAbstractSpinBox", "private", "", "public" ] }, + { symbol: [ "QStyleOptionFrameV2", "private", "", "public" ] }, + { symbol: [ "QStyleOptionTabBarBase", "private", "", "public" ] }, + { symbol: [ "QStyleOptionSlider", "private", "", "public" ] }, + { symbol: [ "QFileSystemModel", "private", "", "public" ] }, + { symbol: [ "QStyle", "private", "", "public" ] }, + { symbol: [ "QStyleOptionToolButton", "private", "", "public" ] }, + { symbol: [ "QLayout", "private", "", "public" ] }, + { symbol: [ "QStyleOptionMenuItem", "private", "", "public" ] }, + { symbol: [ "QPushButton", "private", "", "public" ] }, + { symbol: [ "QGraphicsTransform", "private", "", "public" ] }, + { symbol: [ "QStyleOptionComplex", "private", "", "public" ] }, + { symbol: [ "QHBoxLayout", "private", "", "public" ] }, + { symbol: [ "QStyleOptionTitleBar", "private", "", "public" ] }, + { symbol: [ "QGraphicsSceneHelpEvent", "private", "", "public" ] }, + { symbol: [ "QMenu", "private", "", "public" ] }, + { symbol: [ "QGraphicsScale", "private", "", "public" ] }, + { symbol: [ "QStyleOptionFrame", "private", "", "public" ] }, + { symbol: [ "QScrollArea", "private", "", "public" ] }, + { symbol: [ "QPinchGesture", "private", "", "public" ] }, + { symbol: [ "QFileIconProvider", "private", "", "public" ] }, + { symbol: [ "QDialogButtonBox", "private", "", "public" ] }, + { symbol: [ "QMainWindow", "private", "", "public" ] }, + { symbol: [ "QWizard", "private", "", "public" ] }, + { symbol: [ "QToolBox", "private", "", "public" ] }, + { symbol: [ "QListView", "private", "", "public" ] }, + { symbol: [ "QGraphicsOpacityEffect", "private", "", "public" ] }, + { symbol: [ "QGraphicsItem", "private", "", "public" ] }, + { symbol: [ "QGraphicsSceneDragDropEvent", "private", "", "public" ] }, + { symbol: [ "QTreeView", "private", "", "public" ] }, + { symbol: [ "QUndoStack", "private", "", "public" ] }, + { symbol: [ "QStandardItemEditorCreator", "private", "", "public" ] }, + { symbol: [ "QGraphicsEllipseItem", "private", "", "public" ] }, + { symbol: [ "QTreeWidgetItemIterator", "private", "", "public" ] }, + { symbol: [ "QColorDialog", "private", "", "public" ] }, + { symbol: [ "QScroller", "private", "", "public" ] }, + { symbol: [ "QTreeWidget", "private", "", "public" ] }, + { symbol: [ "QProxyStyle", "private", "", "public" ] }, + { symbol: [ "QStyleOptionViewItem", "private", "", "public" ] }, + { symbol: [ "QInputDialog", "private", "", "public" ] }, + { symbol: [ "QTableWidgetItem", "private", "", "public" ] }, + { symbol: [ "QLineEdit", "private", "", "public" ] }, + { symbol: [ "QPlainTextDocumentLayout", "private", "", "public" ] }, + { symbol: [ "QDialog", "private", "", "public" ] }, + { symbol: [ "QAbstractScrollArea", "private", "", "public" ] }, + { symbol: [ "QGraphicsAnchor", "private", "", "public" ] }, + { symbol: [ "QGraphicsLayoutItem", "private", "", "public" ] }, + { symbol: [ "QItemEditorCreator", "private", "", "public" ] }, + { symbol: [ "QScrollBar", "private", "", "public" ] }, + { symbol: [ "QStyleOptionFrameV3", "private", "", "public" ] }, + { symbol: [ "QStyleOptionToolBoxV2", "private", "", "public" ] }, + { symbol: [ "QSpinBox", "private", "", "public" ] }, + { symbol: [ "QFontDialog", "private", "", "public" ] }, + { symbol: [ "QStyleHintReturnVariant", "private", "", "public" ] }, + { symbol: [ "QGraphicsSceneMouseEvent", "private", "", "public" ] }, + { symbol: [ "QGraphicsItemAnimation", "private", "", "public" ] }, + { symbol: [ "QGraphicsGridLayout", "private", "", "public" ] }, + { symbol: [ "QCompleter", "private", "", "public" ] }, + { symbol: [ "QStylePlugin", "private", "", "public" ] }, + { symbol: [ "QSwipeGesture", "private", "", "public" ] }, + { symbol: [ "QTextBrowser", "private", "", "public" ] }, + { symbol: [ "QFileDialog", "private", "", "public" ] }, + { symbol: [ "QMouseEventTransition", "private", "", "public" ] }, + { symbol: [ "QVBoxLayout", "private", "", "public" ] }, + { symbol: [ "QOpenGLWidget", "private", "", "public" ] }, + { symbol: [ "QCalendarWidget", "private", "", "public" ] }, + { symbol: [ "QStyleHintReturnMask", "private", "", "public" ] }, + { symbol: [ "QGraphicsView", "private", "", "public" ] }, + { symbol: [ "QGraphicsAnchorLayout", "private", "", "public" ] }, + { symbol: [ "QUndoGroup", "private", "", "public" ] }, + { symbol: [ "QGraphicsProxyWidget", "private", "", "public" ] }, + { symbol: [ "QtWidgets", "private", "", "public" ] }, + { symbol: [ "QProgressDialog", "private", "", "public" ] }, + { symbol: [ "QCommandLinkButton", "private", "", "public" ] }, + { symbol: [ "QStyleOptionButton", "private", "", "public" ] }, + { symbol: [ "QToolTip", "private", "", "public" ] }, + { symbol: [ "QAccessibleWidget", "private", "", "public" ] }, + { symbol: [ "QTableWidget", "private", "", "public" ] }, + { symbol: [ "QGraphicsLineItem", "private", "", "public" ] }, + { symbol: [ "QGraphicsLinearLayout", "private", "", "public" ] }, + { symbol: [ "QWidgetData", "private", "", "public" ] }, + { symbol: [ "QStyleHintReturn", "private", "", "public" ] }, + { symbol: [ "QAbstractItemView", "private", "", "public" ] }, + { symbol: [ "QStyledItemDelegate", "private", "", "public" ] }, + { symbol: [ "QStyleOptionViewItemV2", "private", "", "public" ] }, + { symbol: [ "QStackedWidget", "private", "", "public" ] }, + { symbol: [ "QColormap", "private", "", "public" ] }, + { symbol: [ "QWidgetItemV2", "private", "", "public" ] }, + { symbol: [ "QStatusBar", "private", "", "public" ] }, + { symbol: [ "QStyleOptionTabV2", "private", "", "public" ] }, + { symbol: [ "QStyleOptionSpinBox", "private", "", "public" ] }, + { symbol: [ "QProgressBar", "private", "", "public" ] }, + { symbol: [ "QSpacerItem", "private", "", "public" ] }, + { symbol: [ "QFocusFrame", "private", "", "public" ] }, + { symbol: [ "QStyleOptionFocusRect", "private", "", "public" ] }, + { symbol: [ "QGraphicsLayout", "private", "", "public" ] }, + { symbol: [ "QStyleOptionToolBar", "private", "", "public" ] }, + { symbol: [ "QtQuickParticlesVersion", "private", "", "public" ] }, + { symbol: [ "QtQuickParticlesDepends", "private", "", "public" ] }, + { symbol: [ "QtQuickParticles", "private", "", "public" ] }, + { symbol: [ "QDesignerTaskMenuExtension", "private", "", "public" ] }, + { symbol: [ "QDesignerFormEditorPluginInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerActionEditorInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerContainerExtension", "private", "", "public" ] }, + { symbol: [ "QDesignerWidgetFactoryInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerWidgetBoxInterface", "private", "", "public" ] }, + { symbol: [ "QAbstractExtensionFactory", "private", "", "public" ] }, + { symbol: [ "QDesignerComponents", "private", "", "public" ] }, + { symbol: [ "QDesignerPromotionInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerWidgetDataBaseItemInterface", "private", "", "public" ] }, + { symbol: [ "QExtensionFactory", "private", "", "public" ] }, + { symbol: [ "QDesignerLanguageExtension", "private", "", "public" ] }, + { symbol: [ "QDesignerObjectInspectorInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerFormWindowCursorInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerMemberSheetExtension", "private", "", "public" ] }, + { symbol: [ "QDesignerDnDItemInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerIntegration", "private", "", "public" ] }, + { symbol: [ "QDesignerFormEditorInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerCustomWidgetInterface", "private", "", "public" ] }, + { symbol: [ "QAbstractFormBuilder", "private", "", "public" ] }, + { symbol: [ "QDesignerResourceBrowserInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerDynamicPropertySheetExtension", "private", "", "public" ] }, + { symbol: [ "QDesignerIntegrationInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerNewFormWidgetInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerPropertySheetExtension", "private", "", "public" ] }, + { symbol: [ "QtDesignerDepends", "private", "", "public" ] }, + { symbol: [ "QDesignerMetaDataBaseInterface", "private", "", "public" ] }, + { symbol: [ "QExtensionManager", "private", "", "public" ] }, + { symbol: [ "QDesignerFormWindowToolInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerExtraInfoExtension", "private", "", "public" ] }, + { symbol: [ "QDesignerWidgetDataBaseInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerOptionsPageInterface", "private", "", "public" ] }, + { symbol: [ "QFormBuilder", "private", "", "public" ] }, + { symbol: [ "QDesignerSettingsInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerFormWindowManagerInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerCustomWidgetCollectionInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerExportWidget", "private", "", "public" ] }, + { symbol: [ "QDesignerMetaDataBaseItemInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerPropertyEditorInterface", "private", "", "public" ] }, + { symbol: [ "QtDesigner", "private", "", "public" ] }, + { symbol: [ "QtDesignerVersion", "private", "", "public" ] }, + { symbol: [ "QAbstractExtensionManager", "private", "", "public" ] }, + { symbol: [ "QDesignerFormWindowInterface", "private", "", "public" ] }, + { symbol: [ "QDesignerLayoutDecorationExtension", "private", "", "public" ] }, + { symbol: [ "QQuickWidget", "private", "", "public" ] }, + { symbol: [ "QtQuickWidgetsVersion", "private", "", "public" ] }, + { symbol: [ "QtQuickWidgetsDepends", "private", "", "public" ] }, + { symbol: [ "QtQuickWidgets", "private", "", "public" ] }, + { symbol: [ "Qt3DQuickScene2DVersion", "private", "", "public" ] }, + { symbol: [ "Qt3DQuickScene2DDepends", "private", "", "public" ] }, + { symbol: [ "QScene2D", "private", "", "public" ] }, + { symbol: [ "Qt3DQuickScene2D", "private", "", "public" ] }, + { symbol: [ "QQuickWindow", "private", "", "public" ] }, + { symbol: [ "QQuickRenderControl", "private", "", "public" ] }, + { symbol: [ "QSGRenderNode", "private", "", "public" ] }, + { symbol: [ "QSGNode", "private", "", "public" ] }, + { symbol: [ "QSGTexture", "private", "", "public" ] }, + { symbol: [ "QSGEngine", "private", "", "public" ] }, + { symbol: [ "QQuickItemGrabResult", "private", "", "public" ] }, + { symbol: [ "QSGAbstractRenderer", "private", "", "public" ] }, + { symbol: [ "QQuickTransform", "private", "", "public" ] }, + { symbol: [ "QSGMaterialType", "private", "", "public" ] }, + { symbol: [ "QSGGeometryNode", "private", "", "public" ] }, + { symbol: [ "QSGNodeVisitor", "private", "", "public" ] }, + { symbol: [ "QSGBasicGeometryNode", "private", "", "public" ] }, + { symbol: [ "QSGTextureMaterial", "private", "", "public" ] }, + { symbol: [ "QQuickImageResponse", "private", "", "public" ] }, + { symbol: [ "QSGSimpleTextureNode", "private", "", "public" ] }, + { symbol: [ "QSGSimpleRectNode", "private", "", "public" ] }, + { symbol: [ "QQuickTextDocument", "private", "", "public" ] }, + { symbol: [ "QQuickPaintedItem", "private", "", "public" ] }, + { symbol: [ "QSGTextureProvider", "private", "", "public" ] }, + { symbol: [ "QSGOpaqueTextureMaterial", "private", "", "public" ] }, + { symbol: [ "QSGClipNode", "private", "", "public" ] }, + { symbol: [ "QQuickFramebufferObject", "private", "", "public" ] }, + { symbol: [ "QSGFlatColorMaterial", "private", "", "public" ] }, + { symbol: [ "QQuickView", "private", "", "public" ] }, + { symbol: [ "QSGTransformNode", "private", "", "public" ] }, + { symbol: [ "QSGOpacityNode", "private", "", "public" ] }, + { symbol: [ "QSGRectangleNode", "private", "", "public" ] }, + { symbol: [ "QSGMaterial", "private", "", "public" ] }, + { symbol: [ "QSGSimpleMaterial", "private", "", "public" ] }, + { symbol: [ "QtQuickVersion", "private", "", "public" ] }, + { symbol: [ "QQuickItem", "private", "", "public" ] }, + { symbol: [ "QSGDynamicTexture", "private", "", "public" ] }, + { symbol: [ "QSGRootNode", "private", "", "public" ] }, + { symbol: [ "QQuickTextureFactory", "private", "", "public" ] }, + { symbol: [ "QQuickImageProvider", "private", "", "public" ] }, + { symbol: [ "QSGMaterialShader", "private", "", "public" ] }, + { symbol: [ "QtQuickDepends", "private", "", "public" ] }, + { symbol: [ "QSGSimpleMaterialComparableMaterial", "private", "", "public" ] }, + { symbol: [ "QSGVertexColorMaterial", "private", "", "public" ] }, + { symbol: [ "QSGGeometry", "private", "", "public" ] }, + { symbol: [ "QSGSimpleMaterialShader", "private", "", "public" ] }, + { symbol: [ "QSGRendererInterface", "private", "", "public" ] }, + { symbol: [ "QQuickAsyncImageProvider", "private", "", "public" ] }, + { symbol: [ "QSGImageNode", "private", "", "public" ] }, + { symbol: [ "QSGNinePatchNode", "private", "", "public" ] }, + { symbol: [ "QtQuick", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qabstractraycaster\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qcomputecommand\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qabstractfunctor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qabstractlight\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qabstractraycaster\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qabstracttexture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qabstracttextureimage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qalphacoverage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qalphatest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qattribute\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qblendequation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qblendequationarguments\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qblitframebuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qbuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qbuffercapture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qbufferdatagenerator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qcamera\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qcameralens\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qcameraselector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qclearbuffers\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qclipplane\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qcolormask\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qcomputecommand\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qcullface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qdepthtest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qdirectionallight\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qdispatchcompute\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qdithering\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qeffect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qenvironmentlight\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qfilterkey\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qframegraphnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qframegraphnodecreatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qfrontface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qfrustumculling\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qgeometry\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qgeometryfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qgeometryrenderer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qgraphicsapifilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qlayer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qlayerfilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qlevelofdetail\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qlevelofdetailboundingsphere\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qlevelofdetailswitch\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qlinewidth\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qmaterial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qmemorybarrier\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qmesh\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qmultisampleantialiasing\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qnodepthmask\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qnodraw\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qobjectpicker\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpaintedtextureimage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qparameter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpickevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpickingsettings\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpicklineevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpickpointevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpicktriangleevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpointlight\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpointsize\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpolygonoffset\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qproximityfilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qraycaster\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qraycasterhit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrenderaspect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrendercapture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrenderpass\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrenderpassfilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrendersettings\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrenderstate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrenderstateset\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrendersurfaceselector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrendertarget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrendertargetoutput\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrendertargetselector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qsceneloader\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qscissortest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qscreenraycaster\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qseamlesscubemap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qshaderdata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qshaderprogram\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qshaderprogrambuilder\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qsortpolicy\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qspotlight\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qstencilmask\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qstenciloperation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qstenciloperationarguments\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qstenciltest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qstenciltestarguments\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtechnique\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtechniquefilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtexture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtexturedata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtexturegenerator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtextureimage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtextureimagedata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtextureimagedatagenerator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtexturewrapmode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qviewport\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qt3drenderversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qgeometryfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtexturedata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qattribute\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qabstracttexture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qshaderprogrambuilder\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtextureimage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qcamera\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qstenciltest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qgeometry\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrendertargetoutput\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpointlight\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrendertarget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qobjectpicker\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpaintedtextureimage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qabstractfunctor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qt3drenderversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrenderpass\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpicklineevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrenderstateset\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtexturedata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrendercapture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qdepthtest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qbuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qbuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtechniquefilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrenderpassfilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qlayer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qframegraphnodecreatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qseamlesscubemap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qclearbuffers\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtextureimagedata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qshaderprogram\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qparameter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qshaderdata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qsortpolicy\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qgeometryfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qfrontface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtextureimagedatagenerator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qnodepthmask\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qraycaster\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qviewport\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrendercapture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrenderpass\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpickevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qblitframebuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpicktriangleevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qlevelofdetailboundingsphere\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qblendequation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qmemorybarrier\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qframegraphnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpicktriangleevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qfilterkey\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpickevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qgeometryrenderer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qabstractfunctor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qscreenraycaster\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qframegraphnodecreatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qenvironmentlight\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qalphacoverage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qabstracttextureimage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qspotlight\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrenderstate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtextureimagedata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpointsize\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qscissortest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qeffect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qbufferdatagenerator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpolygonoffset\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qcolormask\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qbuffercapture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qstenciltestarguments\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpickpointevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qgraphicsapifilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qcameralens\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtextureimagedatagenerator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpickpointevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtexture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qshaderdata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qmultisampleantialiasing\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qalphatest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtechnique\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qfrustumculling\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpickingsettings\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrendertargetselector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qstenciloperationarguments\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrendersurfaceselector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qdithering\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qclipplane\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qattribute\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qproximityfilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qblendequationarguments\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qmaterial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qlevelofdetail\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qframegraphnodecreatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qcullface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtexturewrapmode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qdispatchcompute\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qabstracttexture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrendersettings\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qstencilmask\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qraycasterhit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qdirectionallight\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qtexturegenerator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qnodraw\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qabstractlight\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qstenciloperation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qsceneloader\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qrenderaspect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qpicklineevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qshaderdata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qlayerfilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DRender/)?qcameraselector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtEglSupport/)?qteglsupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtEglSupport/)?qteglsupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioningQuick/)?qpositioningquickglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioningQuick/)?qtpositioningquickversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioningQuick/)?qtpositioningquickversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_3_2_core\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvalidator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericmatrix\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qiconengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglvertexarrayobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpicture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopengltimerquery\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericmatrix\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericmatrix\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpaintdevicewindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextdocument\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_1_core\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpagesize\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtguiglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qabstracttextdocumentlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessiblebridge\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessibleobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessibleplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qbackingstore\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qbitmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qbrush\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qclipboard\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qcolor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qcursor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qdesktopservices\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qdrag\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qfont\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qfontdatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qfontinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qfontmetrics\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericmatrix\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericpluginfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qglyphrun\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qguiapplication\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qicon\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qiconengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qiconengineplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qimage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qimageiohandler\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qimagereader\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qimagewriter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qinputmethod\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qkeysequence\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qmatrix\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qmatrix4x4\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qmovie\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qoffscreensurface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopengl\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglbuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglcontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopengldebug\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglextrafunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglframebufferobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglpaintdevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglpixeltransferoptions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglshaderprogram\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopengltexture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopengltextureblitter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopengltimerquery\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglversionfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglvertexarrayobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpagedpaintdevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpagelayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpagesize\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpaintdevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpaintdevicewindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpaintengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpainter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpainterpath\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpalette\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpdfwriter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpen\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpicture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpictureformatplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpixelformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpixmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpixmapcache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpolygon\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qquaternion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qrasterwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qrawfont\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qregion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qrgb\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qrgba64\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qscreen\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qsessionmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qstandarditemmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qstatictext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qstylehints\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qsurface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qsurfaceformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qsyntaxhighlighter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextcursor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextdocument\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextdocumentfragment\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextdocumentwriter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtexttable\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtouchdevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtransform\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvalidator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvector2d\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvector3d\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvector4d\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qwindowdefs\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtguiversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_0_compatibility\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_2_compatibility\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpaintengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopengltexture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_3_core\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessibleplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qbrush\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglextrafunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qbitmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qclipboard\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtouchdevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_5_core\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qwindowdefs\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_2_1\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qimagewriter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qstandarditemmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvulkanwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_3_2_compatibility\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qmatrix\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpolygon\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvulkanwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvalidator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qbrush\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qicon\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglframebufferobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_4_core\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessibleobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qbrush\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qfont\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpen\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qimage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpixmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qfontdatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qstatictext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qimage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_3_1\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qbrush\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpagedpaintdevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qsurface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qimageiohandler\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpixmapcache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglbuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_1_0\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpaintdevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopengldebug\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qscreen\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpaintengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglcontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qinputmethod\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qsessionmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_3_0\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvulkaninstance\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_1_3\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvector2d\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_5_compatibility\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpagelayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpolygon\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qdrag\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpixelformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpainterpath\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglpixeltransferoptions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qfontmetrics\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpaintengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_0_core\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvulkanfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglshaderprogram\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglcontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericmatrix\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtransform\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qfontmetrics\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextcursor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtguiversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_1_4\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qwindowdefs\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_3_compatibility\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_1_5\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_2_core\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvalidator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglframebufferobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpictureformatplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessiblebridge\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopengldebug\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvulkanfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericmatrix\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qcursor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_es2\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglversionfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qabstracttextdocumentlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qwindowdefs\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qkeysequence\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_1_2\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericmatrix\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessiblebridge\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglshaderprogram\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qfontinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qabstracttextdocumentlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_2_0\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvulkaninstance\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qimagereader\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpainter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qimageiohandler\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpdfwriter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtexttable\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopengltimerquery\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglextrafunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_4_compatibility\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglcontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qbrush\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qwindowdefs\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopengltextureblitter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qglyphrun\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvalidator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_1_compatibility\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_1_1\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qiconengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericpluginfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qbrush\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericmatrix\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qmovie\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericmatrix\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qsurfaceformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvulkaninstance\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qguiapplication\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qmatrix4x4\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_3_3_compatibility\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpicture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qrasterwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qstylehints\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qrgb\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qiconengineplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpalette\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qregion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qrawfont\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvalidator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qimage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextdocumentwriter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qoffscreensurface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qquaternion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvulkaninstance\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qdesktopservices\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextdocumentfragment\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qsyntaxhighlighter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qcolor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvector4d\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qrgba64\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qstandarditemmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvector3d\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qbackingstore\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qbrush\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextdocument\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtexttable\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_3_3_core\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglpaintdevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessibleobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericmatrix\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qwebframe\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qtwebkitwidgetsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qgraphicswebview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qwebframe\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qwebinspector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qwebpage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qwebview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qwebview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qwebinspector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qtwebkitwidgetsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qwebpage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qgraphicswebview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qwebframe\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtestevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtest_gui\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtestdata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtestaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qttestglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qabstractitemmodeltester\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qbenchmark\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qbenchmarkmetric\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qsignalspy\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtestassert\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtestcase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtestdata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtesteventloop\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtestsystem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qttestversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qttestversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtestspontaneevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtestevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtest_network\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qsignalspy\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtesteventloop\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtestevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtest_widgets\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtestevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtestevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qabstractitemmodeltester\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtestspontaneevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtestevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qtnetworkversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkconfiguration\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qabstractnetworkcache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkdatagram\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkproxy\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qhstspolicy\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslkey\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworksession\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qtnetworkglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qabstractnetworkcache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qabstractsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qauthenticator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qdnslookup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qhostaddress\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qhostinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qhstspolicy\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qhttpmultipart\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qlocalserver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qlocalsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkaccessmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkconfigmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkconfiguration\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkcookie\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkcookiejar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkdatagram\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkdiskcache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkproxy\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkrequest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworksession\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsctpserver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsctpsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qssl\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslcertificate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslcertificateextension\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslcipher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslconfiguration\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qssldiffiehellmanparameters\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslellipticcurve\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslerror\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslkey\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslpresharedkeyauthenticator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qtcpserver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qtcpsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qudpsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qtnetworkversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qlocalserver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslcipher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslerror\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qdnslookup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qhttpmultipart\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkaccessmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslconfiguration\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkconfigmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkcookiejar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qdnslookup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qdnslookup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qhttpmultipart\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qhostaddress\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qhostaddress\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslpresharedkeyauthenticator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qlocalsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qhostaddress\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsctpsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qtcpsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkproxy\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkdiskcache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsctpserver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qabstractsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qudpsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qauthenticator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkproxy\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qdnslookup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qhostinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qssl\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qssldiffiehellmanparameters\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkrequest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslellipticcurve\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslcertificateextension\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qdnslookup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qabstractnetworkcache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qtcpserver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qdnslookup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkcookie\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslcertificate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtEglFSDeviceIntegration/)?qteglfsdeviceintegrationversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtEglFSDeviceIntegration/)?qteglfsdeviceintegrationversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusabstractinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusextratypes\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbuspendingcall\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusconnection\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusunixfiledescriptor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qtdbusglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusabstractadaptor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusabstractinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusargument\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusconnection\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusconnectioninterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbuscontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbuserror\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusextratypes\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusmessage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusmetatype\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbuspendingcall\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbuspendingreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusserver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusservicewatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusunixfiledescriptor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusvirtualobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qtdbusversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusabstractadaptor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbuscontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusmetatype\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusargument\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qtdbusversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusserver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbuspendingreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusservicewatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusabstractinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbuspendingcall\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbuspendingreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusextratypes\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusconnectioninterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusvirtualobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbuserror\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusmessage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qtprintsupportglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qabstractprintdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qpagesetupdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprintdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprintengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprinter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprinterinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprintpreviewdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprintpreviewwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qtprintsupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprinterinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprinter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprintengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qtprintsupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qpagesetupdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprintdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprintpreviewdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprintpreviewwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qabstractprintdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeopositioninfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeoareamonitorinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeorectangle\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeosatelliteinfosource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeocoordinate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qpositioningglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeoaddress\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeoareamonitorinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeoareamonitorsource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeocircle\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeocoordinate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeolocation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeopath\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeopolygon\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeopositioninfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeopositioninfosource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeopositioninfosourcefactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeorectangle\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeosatelliteinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeosatelliteinfosource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeoshape\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qnmeapositioninfosource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qtpositioningversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeopositioninfosourcefactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeolocation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeopolygon\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeocircle\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeosatelliteinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeoaddress\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeopositioninfosource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeopolygon\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeoareamonitorsource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qtpositioningversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeoshape\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qnmeapositioninfosource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSvg/)?qtsvgglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSvg/)?qgraphicssvgitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSvg/)?qsvggenerator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSvg/)?qsvgrenderer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSvg/)?qsvgwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSvg/)?qtsvgversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSvg/)?qgraphicssvgitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSvg/)?qsvggenerator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSvg/)?qsvgwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSvg/)?qsvgrenderer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSvg/)?qtsvgversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtThemeSupport/)?qtthemesupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtThemeSupport/)?qtthemesupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DQuickRender/)?qt3dquickrenderversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DQuickRender/)?qt3dquickrenderversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuickTest/)?quicktestglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuickTest/)?quicktest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuickTest/)?qtquicktestversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuickTest/)?qtquicktestversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQmlDebug/)?qtqmldebugversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQmlDebug/)?qtqmldebugversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlrelationaltablemodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlfield\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlquerymodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlerror\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqltablemodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqldatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qtsqlglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqldatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqldriver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqldriverplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlerror\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlfield\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlindex\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlquery\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlquerymodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlrecord\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlrelationaldelegate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlrelationaltablemodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlresult\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqltablemodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qtsqlversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlrelationaltablemodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlquery\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlrelationaldelegate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qtsqlversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlindex\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqldriverplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlrecord\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqldatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqldatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlresult\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqldriver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qtsqlglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGlxSupport/)?qtglxsupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGlxSupport/)?qtglxsupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformCompositorSupport/)?qtplatformcompositorsupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformCompositorSupport/)?qtplatformcompositorsupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlresultitems\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qabstractxmlnodemodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlschema\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlschemavalidator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlnamepool\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qabstractmessagehandler\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qsimplexmlnodemodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlserializer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qtxmlpatternsglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qabstractmessagehandler\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qabstracturiresolver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qabstractxmlnodemodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qabstractxmlreceiver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qsimplexmlnodemodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qsourcelocation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlformatter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlname\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlnamepool\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlquery\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlresultitems\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlschema\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlschemavalidator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlserializer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qtxmlpatternsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlname\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qabstracturiresolver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qabstractxmlnodemodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qtxmlpatternsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qabstractxmlreceiver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlformatter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qabstractxmlnodemodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qsourcelocation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlquery\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtAccessibilitySupport/)?qtaccessibilitysupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtAccessibilitySupport/)?qtaccessibilitysupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DQuick/)?qqmlaspectengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DQuick/)?qqmlaspectengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DQuick/)?qt3dquickversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DQuick/)?qt3dquickversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qwindowswindowfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qxcbintegrationfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qeglnativecontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qplatformheaderhelper\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qcocoanativecontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qxcbwindowfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qeglfsfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qwaylandwindowfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qxcbscreenfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qcocoanativecontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qcocoawindowfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qeglfsfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qeglnativecontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qglxnativecontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qplatformheaderhelper\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qwaylandwindowfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qwglnativecontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qwindowswindowfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qxcbintegrationfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qxcbscreenfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qxcbwindowfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qtplatformheadersversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qwglnativecontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qtplatformheadersversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qglxnativecontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qcocoawindowfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtKmsSupport/)?qtkmssupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtKmsSupport/)?qtkmssupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qscenechange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qaspectjob\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertynodeaddedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qskeletonloader\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qbackendnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyvalueremovedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyupdatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qabstractaspect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyvalueremovedchangebase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertynoderemovedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyupdatedchangebase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qskeleton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnodecommand\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyvalueaddedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qabstractaspect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qabstractskeleton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qdynamicpropertyupdatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qstaticpropertyvalueremovedchangebase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qabstractaspect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qcomponentremovedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyvalueaddedchangebase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertynodeaddedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qbackendnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qstaticpropertyvalueaddedchangebase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnodeid\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qstaticpropertyupdatedchangebase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyupdatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qcomponent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qentity\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyvalueremovedchangebase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertynoderemovedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnodecommand\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qtransform\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qabstractaspect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qabstractskeleton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qarmature\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qaspectengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qaspectjob\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qbackendnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qcomponent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qcomponentaddedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qcomponentremovedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qdynamicpropertyupdatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qentity\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qjoint\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnodecommand\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnodecreatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnodedestroyedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnodeid\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertynodeaddedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertynoderemovedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyupdatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyupdatedchangebase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyvalueaddedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyvalueaddedchangebase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyvalueremovedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyvalueremovedchangebase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qscenechange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qskeleton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qskeletonloader\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qstaticpropertyupdatedchangebase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qstaticpropertyvalueaddedchangebase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qstaticpropertyvalueremovedchangebase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qtransform\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qt3dcoreversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnodecreatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qaspectengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyupdatedchangebase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qentity\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnodedestroyedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qstaticpropertyupdatedchangebase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qt3dcoreversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qcomponentaddedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qscenechange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnodecreatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnodecreatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qarmature\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyvalueaddedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qaspectengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qcomponentremovedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qnodedestroyedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qjoint\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qdynamicpropertyupdatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyvalueaddedchangebase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qpropertyvalueremovedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DCore/)?qcomponentaddedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtUiPlugin/)?qtuipluginversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtUiPlugin/)?customwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtUiPlugin/)?customwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtUiPlugin/)?qdesignerexportwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtUiPlugin/)?qtuipluginversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtUiPlugin/)?customwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtUiPlugin/)?qdesignerexportwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DLogic/)?qframeaction\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DLogic/)?qframeaction\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DLogic/)?qlogicaspect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DLogic/)?qt3dlogicversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DLogic/)?qlogicaspect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DLogic/)?qt3dlogicversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtFbSupport/)?qtfbsupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtFbSupport/)?qtfbsupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtEdidSupport/)?qtedidsupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtEdidSupport/)?qtedidsupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesignerComponents/)?qtdesignercomponentsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesignerComponents/)?qtdesignercomponentsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSerialPort/)?qserialportinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSerialPort/)?qserialportglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSerialPort/)?qserialport\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSerialPort/)?qserialportinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSerialPort/)?qtserialportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSerialPort/)?qtserialportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSerialPort/)?qserialport\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeviceDiscoverySupport/)?qtdevicediscoverysupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeviceDiscoverySupport/)?qtdevicediscoverysupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qxml\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qxml\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qtxmlversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qxml\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qxml\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qxml\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qxml\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qxml\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qxml\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qtxmlglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qxml\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qtxmlversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qxml\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qxml\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qxml\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qxml\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qxml\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qxml\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qdom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGLExtensions/)?qtopenglextensionsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGLExtensions/)?qopenglextensions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGLExtensions/)?qopenglextensions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGLExtensions/)?qtopenglextensionsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlextensioninterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlscriptstring\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlpropertymap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlerror\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlpropertyvaluesource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlproperty\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlfileselector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlprivate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlabstracturlinterceptor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qjsvalueiterator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmldebug\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlnetworkaccessmanagerfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlprivate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlcomponent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qjsvalue\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlparserstatus\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlincubator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlextensionplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlexpression\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlextensioninterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlcontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qjsvalue\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlfile\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qjsengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qtqmlversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qtqmlglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qjsengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qjsvalue\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qjsvalueiterator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqml\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlabstracturlinterceptor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlapplicationengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlcomponent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlcontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmldebug\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlerror\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlexpression\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlextensioninterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlextensionplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlfile\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlfileselector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlincubator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmllist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlnetworkaccessmanagerfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlparserstatus\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlprivate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlproperty\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlpropertymap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlpropertyvaluesource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlscriptstring\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qtqmlversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlproperty\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlapplicationengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmllist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlincubator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmllist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DQuickInput/)?qt3dquickinputversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DQuickInput/)?qt3dquickinputversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebkitplatformplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebsettings\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebhistory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebdatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebkitplatformplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebkitplatformplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebkitplatformplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebkitplatformplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebsecurityorigin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebkitplatformplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebelement\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebkitplatformplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebkitplatformplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qtwebkitversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebhistory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebhistoryinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebfullscreenrequest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebkitglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qtwebkitversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebdatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebelement\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebfullscreenrequest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebhistory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebhistoryinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebkitplatformplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebpluginfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebsecurityorigin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebsettings\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebelement\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebkitplatformplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebpluginfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtFontDatabaseSupport/)?qtfontdatabasesupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtFontDatabaseSupport/)?qtfontdatabasesupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtX11Extras/)?qtx11extrasversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtX11Extras/)?qx11info_x11\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtX11Extras/)?qtx11extrasglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtX11Extras/)?qtx11extrasversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentrun\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentfilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentcompilertest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentexception\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentfilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentfilterkernel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentfunctionwrappers\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentiteratekernel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentmapkernel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentmedian\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentreducekernel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentrun\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentrunbase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentstoredfunctioncall\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentthreadengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpcontentwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelp_global\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpsearchengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpcontentwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpsearchresultwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpsearchengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpsearchquerywidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qthelpversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpindexwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpcontentwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpsearchengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpcontentwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpenginecore\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpindexwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpsearchengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpsearchquerywidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpsearchresultwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qthelpversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpindexwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpenginecore\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtUiTools/)?quiloader\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtUiTools/)?qtuitoolsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtUiTools/)?quiloader\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtUiTools/)?qtuitoolsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtEventDispatcherSupport/)?qteventdispatchersupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtEventDispatcherSupport/)?qteventdispatchersupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qxmlstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdatetime\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfileselector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvariant\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qatomic\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdatetime\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qqueue\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtranslator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbytearray\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringliteral\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qxmlstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qparallelanimationgroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpropertyanimation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qset\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcontiguouscache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcontainerfwd\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlinkedlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmimedata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbytearray\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsavefile\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtemporarydir\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstring\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlinkedlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qreadwritelock\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qset\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qxmlstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlinkedlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmimedatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfuturesynchronizer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfinalstate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractnativeeventfilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtimezone\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qscopedpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpoint\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobjectdefs\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsysinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qxmlstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfuturewatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qscopedvaluerollback\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qxmlstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractstate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcollator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?quuid\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfutureinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdebug\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstracttransition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtimer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtypeinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qitemselectionmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlogging\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qregexp\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcoreapplication\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstack\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qendian\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfuture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qprocess\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qendian\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qchar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmetaobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qprocess\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringliteral\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qline\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtimeline\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qatomic\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qatomic\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qxmlstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsize\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qarraydata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qnamespace\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qscopedpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qshareddata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qloggingcategory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfileinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbytearray\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsignaltransition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qendian\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qline\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qendian\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qeasingcurve\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlinkedlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbytearray\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmargins\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstatemachine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qscopedpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtextcodec\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qurl\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfactoryinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractitemmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfiledevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpair\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qjsonarray\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qprocess\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qjsonvalue\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qflags\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbitarray\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qarraydatapointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qflags\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvariant\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qthreadpool\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qelapsedtimer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qendian\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtextcodec\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qexception\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmetaobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlocale\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qscopedpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbasictimer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdatetime\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qarraydata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qendian\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvariantanimation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfuturewatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfuture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbytearraylist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfuture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qversionnumber\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstring\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtextcodec\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtextstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobjectcleanuphandler\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpoint\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qreadwritelock\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvariant\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qrandom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstring\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlogging\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qjsonvalue\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcoreevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qreadwritelock\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qshareddata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdiriterator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcoreapplication\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlogging\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractproxymodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtcoreversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstorageinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlibraryinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsignalmapper\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtypeinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qhashfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcontiguouscache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qrandom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qhash\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qrect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlibrary\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdebug\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcontiguouscache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsequentialanimationgroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qidentityproxymodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qscopedpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtextstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qitemselectionmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmargins\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qxmlstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qeventloop\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qconfig\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qjsonvalue\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qthread\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcoreevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcollator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlinkedlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qhash\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmimetype\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qalgorithms\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qitemselectionmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmetatype\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringalgorithms\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstandardpaths\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsemaphore\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qrunnable\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdatastream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractitemmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsharedpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvarlengtharray\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstracteventdispatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qwaitcondition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qglobalstatic\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbytearraylist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfile\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcommandlineoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qxmlstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbytearraylist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qanimationgroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractitemmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringliteral\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmetaobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringlistmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractitemmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpluginloader\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qset\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlockfile\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcoreevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qxmlstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qchar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdebug\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcoreevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmetaobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcommandlineparser\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsemaphore\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfutureinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsharedmemory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmutex\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpauseanimation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qeventloop\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdeadlinetimer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstring\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qurlquery\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbytearraymatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsize\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdir\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qjsonobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qiterator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qjsondocument\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobjectdefs\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qregularexpression\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsharedpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qresource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qflags\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qprocess\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringmatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qxmlstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfileinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmutex\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qwineventnotifier\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qurl\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractitemmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qhash\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtemporaryfile\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsortfilterproxymodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsettings\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qthreadstorage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qnamespace\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractanimation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qregularexpression\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdebug\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvariant\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbytearraymatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qxmlstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbitarray\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qhash\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qrect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractanimation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstracteventdispatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractitemmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractnativeeventfilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractproxymodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractstate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstracttransition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qalgorithms\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qanimationgroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qarraydata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qarraydataops\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qarraydatapointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qatomic\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbasictimer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbitarray\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbytearray\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbytearraylist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbytearraymatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qchar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcollator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcommandlineoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcommandlineparser\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcompilerdetection\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcontainerfwd\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcontiguouscache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcoreapplication\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcoreevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcryptographichash\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdatastream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdatetime\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdeadlinetimer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdebug\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdir\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdiriterator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qeasingcurve\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qelapsedtimer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qendian\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qeventloop\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qeventtransition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qexception\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfactoryinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfile\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfiledevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfileinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfileselector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfilesystemwatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfinalstate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qflags\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfuture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfutureinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfuturesynchronizer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfuturewatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qgenericatomic\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qglobalstatic\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qhash\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qhashfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qhistorystate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qidentityproxymodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qiodevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qisenum\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qitemselectionmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qiterator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qjsonarray\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qjsondocument\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qjsonobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qjsonvalue\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlibrary\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlibraryinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qline\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlinkedlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlocale\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlockfile\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qloggingcategory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmargins\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmath\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmessageauthenticationcode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmetaobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmetatype\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmimedata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmimedatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmimetype\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmutex\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qnamespace\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qnumeric\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobjectcleanuphandler\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobjectdefs\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qoperatingsystemversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpair\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qparallelanimationgroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpauseanimation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpluginloader\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpoint\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qprocess\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qprocessordetection\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpropertyanimation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qqueue\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qrandom\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qreadwritelock\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qrect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qrefcount\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qregexp\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qregularexpression\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qresource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qresultstore\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qrunnable\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsavefile\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qscopedpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qscopedvaluerollback\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsemaphore\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsequentialanimationgroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qset\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsettings\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qshareddata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsharedmemory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsharedpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsignalmapper\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsignaltransition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsize\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsocketnotifier\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsortfilterproxymodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstack\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstandardpaths\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstatemachine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstorageinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstring\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringalgorithms\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringbuilder\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringlistmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringliteral\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringmatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsysinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsystemdetection\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsystemsemaphore\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtemporarydir\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtemporaryfile\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtextboundaryfinder\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtextcodec\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtextstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qthread\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qthreadpool\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qthreadstorage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtimeline\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtimer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtimezone\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtranslator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtypeinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtypetraits\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qurl\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qurlquery\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?quuid\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvariant\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvariantanimation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvarlengtharray\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qversionnumber\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qversiontagging\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qwaitcondition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qwineventnotifier\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qxmlstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtcoreversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtextboundaryfinder\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcoreevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtextstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtypeinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfloat16\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qarraydata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qthreadstorage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvariant\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmutex\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qoperatingsystemversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmessageauthenticationcode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobjectdefs\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qjsondocument\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlogging\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstring\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringliteral\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qnumeric\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qexception\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qscopedpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qxmlstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsocketnotifier\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractitemmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qjsonvalue\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qeventtransition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvariant\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobjectdefs\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qscopedpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsharedpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringbuilder\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractanimation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qhash\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobjectdefs\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfilesystemwatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qshareddata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qhistorystate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qiodevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qprocess\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsystemsemaphore\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobjectdefs\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPacketProtocol/)?qtpacketprotocolversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPacketProtocol/)?qtpacketprotocolversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLinuxAccessibilitySupport/)?qtlinuxaccessibilitysupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLinuxAccessibilitySupport/)?qtlinuxaccessibilitysupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglframebufferobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglframebufferobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qgl\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglpixelbuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qtopenglversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglbuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglcolormap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglshaderprogram\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglshaderprogram\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qgl\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qgl\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qtopenglglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qgl\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglbuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglcolormap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglframebufferobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglpixelbuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglshaderprogram\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qtopenglversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qgl\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qt3dinputversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qmousehandler\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qphysicaldevicecreatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qaxis\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qmouseevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qlogicaldevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qactioninput\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qkeyboarddevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qmouseevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qkeyevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qabstractactioninput\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qkeyevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qaction\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qmouseevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qinputaspect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qinputchord\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qphysicaldevicecreatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qanalogaxisinput\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qaxissetting\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qmousedevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qabstractaxisinput\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qmouseevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qphysicaldevicecreatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qbuttonaxisinput\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qinputsequence\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qinputsettings\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qabstractactioninput\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qabstractaxisinput\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qabstractphysicaldevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qaction\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qactioninput\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qanalogaxisinput\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qaxis\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qaxisaccumulator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qaxissetting\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qbuttonaxisinput\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qinputaspect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qinputchord\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qinputsequence\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qinputsettings\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qkeyboarddevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qkeyboardhandler\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qkeyevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qlogicaldevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qmousedevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qmouseevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qmousehandler\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qphysicaldevicecreatedchange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qt3dinputversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qabstractphysicaldevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qaxisaccumulator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DInput/)?qkeyboardhandler\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtServiceSupport/)?qtservicesupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtServiceSupport/)?qtservicesupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtInputSupport/)?qintegrityhidmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtInputSupport/)?qintegrityhidmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtInputSupport/)?qtinputsupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtInputSupport/)?qtinputsupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtVulkanSupport/)?qtvulkansupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtVulkanSupport/)?qtvulkansupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qsystemtrayicon\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdirmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgesture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdrawutil\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtextedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qkeyeventtransition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgridlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicssceneevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcolumnview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicseffect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qshortcut\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicswidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgesture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qitemdelegate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicseffect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qsizepolicy\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstylefactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlistwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicssceneevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicstransform\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractslider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfontcombobox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qkeysequenceedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qframe\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlistwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qsplashscreen\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicseffect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicssceneevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qscrollerproperties\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractbutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtabwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtreewidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcombobox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qspinbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qsizegrip\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtabbar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgroupbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmenubar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qformlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmessagebox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qwhatsthis\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicssceneevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlcdnumber\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qapplication\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qwizard\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgesture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qslider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qrubberband\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlayoutitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qsplitter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractitemdelegate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qundoview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmacnativewidget_mac\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsscene\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qbuttongroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtoolbar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmaccocoaviewcontainer_mac\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdatetimeedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qplaintextedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtableview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgesture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmdiarea\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicssceneevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qheaderview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdatawidgetmapper\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcommonstyle\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qitemeditorfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdesktopwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qwidgetaction\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdatetimeedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qactiongroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlabel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qundostack\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlayoutitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstackedlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgesturerecognizer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qboxlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicseffect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qitemeditorfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtwidgetsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstylepainter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtoolbutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qerrormessage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdockwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qaction\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicssceneevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmdisubwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgesture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdatetimeedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qsplitter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qradiobutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcheckbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtablewidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractspinbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfilesystemmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyle\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qpushbutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicstransform\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qboxlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicssceneevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmenu\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicstransform\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qscrollarea\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgesture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfileiconprovider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdialogbuttonbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmainwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qwizard\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtoolbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlistview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicseffect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicssceneevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtreeview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qundostack\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qitemeditorfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtreewidgetitemiterator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcolordialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qscroller\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtreewidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qproxystyle\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qinputdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtablewidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlineedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qplaintextedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractscrollarea\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsanchorlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicslayoutitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qitemeditorfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qscrollbar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qspinbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfontdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicssceneevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitemanimation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsgridlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcompleter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgesture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtextbrowser\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfiledialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmouseeventtransition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qboxlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qopenglwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcalendarwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsanchorlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qundogroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsproxywidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtwidgetsglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractbutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractitemdelegate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractitemview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractscrollarea\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractslider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractspinbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qaccessiblewidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qaction\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qactiongroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qapplication\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qboxlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qbuttongroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcalendarwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcheckbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcolordialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcolormap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcolumnview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcombobox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcommandlinkbutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcommonstyle\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcompleter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdatawidgetmapper\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdatetimeedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdesktopwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdialogbuttonbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdirmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdockwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdrawutil\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qerrormessage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfiledialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfileiconprovider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfilesystemmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfocusframe\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfontcombobox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfontdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qformlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qframe\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgesture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgesturerecognizer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsanchorlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicseffect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsgridlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitemanimation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicslayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicslayoutitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicslinearlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsproxywidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsscene\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicssceneevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicstransform\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicswidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgridlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgroupbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qheaderview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qinputdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qitemdelegate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qitemeditorfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qkeyeventtransition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qkeysequenceedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlabel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlayoutitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlcdnumber\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlineedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlistview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlistwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmainwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmdiarea\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmdisubwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmenu\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmenubar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmessagebox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmouseeventtransition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qopenglwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qplaintextedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qprogressbar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qprogressdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qproxystyle\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qpushbutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qradiobutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qrubberband\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qscrollarea\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qscrollbar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qscroller\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qscrollerproperties\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qshortcut\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qsizegrip\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qsizepolicy\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qslider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qspinbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qsplashscreen\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qsplitter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstackedlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstackedwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstatusbar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyle\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleditemdelegate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstylefactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstylepainter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qsystemtrayicon\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtabbar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtableview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtablewidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtabwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtextbrowser\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtextedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtoolbar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtoolbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtoolbutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtooltip\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtreeview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtreewidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtreewidgetitemiterator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qundogroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qundostack\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qundoview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qwhatsthis\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qwidgetaction\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qwizard\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtwidgetsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qprogressdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcommandlinkbutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtooltip\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qaccessiblewidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtablewidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicslinearlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractitemview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleditemdelegate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstackedwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcolormap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlayoutitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstatusbar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qprogressbar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlayoutitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfocusframe\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicslayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuickParticles/)?qtquickparticlesversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuickParticles/)?qtquickparticlesversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?taskmenu\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractformeditorplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractactioneditor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?container\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractwidgetfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractwidgetbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?extension\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?qdesigner_components\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractpromotioninterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractwidgetdatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?default_extensionfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractlanguage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractobjectinspector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractformwindowcursor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?membersheet\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractdnditem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractintegration\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractformeditor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractformbuilder\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractresourcebrowser\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?dynamicpropertysheet\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractintegration\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractnewformwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?propertysheet\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractmetadatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?qextensionmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractformwindowtool\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?extrainfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractwidgetdatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractoptionspage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?formbuilder\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractsettings\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractformwindowmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractmetadatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractpropertyeditor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractactioneditor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractdnditem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractformbuilder\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractformeditor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractformeditorplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractformwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractformwindowcursor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractformwindowmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractformwindowtool\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractintegration\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractlanguage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractmetadatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractnewformwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractobjectinspector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractoptionspage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractpromotioninterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractpropertyeditor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractresourcebrowser\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractsettings\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractwidgetbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractwidgetdatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractwidgetfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?container\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?dynamicpropertysheet\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?extension\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?extrainfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?formbuilder\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?layoutdecoration\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?membersheet\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?propertysheet\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?qextensionmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?taskmenu\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?qtdesignerversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?qtdesignerversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?extension\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?abstractformwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?layoutdecoration\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuickWidgets/)?qquickwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuickWidgets/)?qtquickwidgetsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuickWidgets/)?qtquickwidgetsglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuickWidgets/)?qquickwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuickWidgets/)?qtquickwidgetsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DQuickScene2D/)?qt3dquickscene2dversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DQuickScene2D/)?qscene2d\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DQuickScene2D/)?qscene2d\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Qt3DQuickScene2D/)?qt3dquickscene2dversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickrendercontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgrendernode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgtexture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickitemgrabresult\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgabstractrenderer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgmaterial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgtexturematerial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickimageprovider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgsimpletexturenode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgsimplerectnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquicktextdocument\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickpainteditem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgtextureprovider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgtexturematerial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickframebufferobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgflatcolormaterial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgrectanglenode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgmaterial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgsimplematerial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qtquickversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgtexture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickimageprovider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickimageprovider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgmaterial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgsimplematerial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgvertexcolormaterial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsggeometry\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgsimplematerial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgrendererinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickimageprovider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgimagenode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgninepatchnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qtquickglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickframebufferobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickimageprovider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickitemgrabresult\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickpainteditem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickrendercontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquicktextdocument\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgabstractrenderer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgflatcolormaterial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsggeometry\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgimagenode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgmaterial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgninepatchnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgrectanglenode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgrendererinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgrendernode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgsimplematerial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgsimplerectnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgsimpletexturenode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgtexture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgtexturematerial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgtextureprovider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgvertexcolormaterial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qtquickversion\\.h[\">]", "private", "", "public" ] } +] diff --git a/qt5_4.imp b/qt5_4.imp index 4e0a421..0e21461 100644 --- a/qt5_4.imp +++ b/qt5_4.imp @@ -1601,865 +1601,865 @@ # perl -le "use File::Find;use File::Basename; sub wanted { $x = lc $_. '.h'; print ' { include: [ -@\-('.basename($File::Find::dir).'/)?'.$x.'\--, -private-, -<'.$_.'>-, -public- ] },' if -e $x } find(\&wanted, '.')" # on windows - { include: [ "@\"(ActiveQt/)?activeqtversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(ActiveQt/)?qaxaggregated\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(ActiveQt/)?qaxbase\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(ActiveQt/)?qaxbindable\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(ActiveQt/)?qaxfactory\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(ActiveQt/)?qaxobject\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(ActiveQt/)?qaxscript\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(ActiveQt/)?qaxselect\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(ActiveQt/)?qaxwidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(Enginio/)?enginio\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(Enginio/)?enginioversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qbluetoothaddress\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qbluetoothdevicediscoveryagent\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qbluetoothdeviceinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qbluetoothhostinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qbluetoothlocaldevice\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qbluetoothserver\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qbluetoothservicediscoveryagent\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qbluetoothserviceinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qbluetoothsocket\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qbluetoothtransfermanager\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qbluetoothtransferreply\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qbluetoothtransferrequest\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qbluetoothuuid\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qlowenergycharacteristic\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qlowenergycontroller\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qlowenergydescriptor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qlowenergyservice\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtBluetooth/)?qtbluetoothversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCLucene/)?qtcluceneversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtConcurrent/)?qtconcurrentfilter\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtConcurrent/)?qtconcurrentmap\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtConcurrent/)?qtconcurrentrun\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtConcurrent/)?qtconcurrentversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qabstractanimation\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qabstracteventdispatcher\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qabstractitemmodel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qabstractnativeeventfilter\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qabstractproxymodel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qabstractstate\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qabstracttransition\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qanimationgroup\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qarraydata\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qarraydatapointer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qbasictimer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qbitarray\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qbuffer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qbytearray\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qbytearraylist\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qbytearraymatcher\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qcache\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qchar\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qcollator\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qcommandlineoption\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qcommandlineparser\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qcontiguouscache\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qcoreapplication\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qcryptographichash\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qdatastream\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qdatetime\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qdebug\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qdir\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qdiriterator\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qeasingcurve\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qelapsedtimer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qeventloop\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qeventtransition\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qexception\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qfactoryinterface\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qfile\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qfiledevice\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qfileinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qfileselector\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qfilesystemwatcher\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qfinalstate\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qflags\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qfuture\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qfutureinterface\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qfuturesynchronizer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qfuturewatcher\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qglobalstatic\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qhash\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qhistorystate\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qidentityproxymodel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qiodevice\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qitemselectionmodel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qjsonarray\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qjsondocument\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qjsonobject\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qjsonvalue\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qlibrary\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qlibraryinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qline\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qlinkedlist\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qlist\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qlocale\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qlockfile\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qloggingcategory\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qmap\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qmargins\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qmessageauthenticationcode\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qmetaobject\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qmetatype\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qmimedata\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qmimedatabase\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qmimetype\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qmutex\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qobject\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qobjectcleanuphandler\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qpair\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qparallelanimationgroup\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qpauseanimation\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qpluginloader\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qpoint\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qpointer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qprocess\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qpropertyanimation\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qqueue\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qreadwritelock\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qrect\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qregexp\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qregularexpression\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qresource\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qrunnable\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qsavefile\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qscopedpointer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qscopedvaluerollback\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qsemaphore\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qsequentialanimationgroup\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qset\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qsettings\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qshareddata\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qsharedmemory\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qsharedpointer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qsignalmapper\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qsignaltransition\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qsize\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qsocketnotifier\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qsortfilterproxymodel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qstack\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qstandardpaths\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qstate\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qstatemachine\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qstorageinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qstring\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qstringbuilder\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qstringlist\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qstringlistmodel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qstringmatcher\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qsysinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qsystemsemaphore\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qtcoreversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qtemporarydir\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qtemporaryfile\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qtextboundaryfinder\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qtextcodec\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qtextstream\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qthread\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qthreadpool\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qthreadstorage\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qtimeline\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qtimer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qtimezone\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qtranslator\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qtypeinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qurl\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qurlquery\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?quuid\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qvariant\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qvariantanimation\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qvarlengtharray\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qvector\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qwaitcondition\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qwineventnotifier\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbusabstractadaptor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbusabstractinterface\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbusargument\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbusconnection\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbusconnectioninterface\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbuscontext\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbuserror\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbusinterface\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbusmessage\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbusmetatype\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbuspendingcall\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbuspendingreply\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbusreply\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbusserver\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbusservicewatcher\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbusunixfiledescriptor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qdbusvirtualobject\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDBus/)?qtdbusversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativecomponent\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativecontext\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativeengine\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativeerror\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativeexpression\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativeextensioninterface\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativeextensionplugin\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativeimageprovider\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativeinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativeitem\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativenetworkaccessmanagerfactory\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativeparserstatus\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativeproperty\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativepropertymap\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativepropertyvalueinterceptor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativepropertyvaluesource\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativescriptstring\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qdeclarativeview\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDeclarative/)?qtdeclarativeversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDesigner/)?qdesignerexportwidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDesigner/)?qextensionmanager\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDesigner/)?qtdesignerversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtDesignerComponents/)?qtdesignercomponentsversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qabstracttextdocumentlayout\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qaccessible\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qaccessiblebridge\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qaccessibleobject\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qaccessibleplugin\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qbackingstore\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qbitmap\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qbrush\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qclipboard\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qcolor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qcursor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qdesktopservices\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qdrag\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qfont\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qfontdatabase\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qfontinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qfontmetrics\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qgenericmatrix\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qgenericplugin\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qgenericpluginfactory\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qglyphrun\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qguiapplication\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qicon\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qiconengine\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qiconengineplugin\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qimage\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qimageiohandler\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qimagereader\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qimagewriter\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qinputmethod\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qkeysequence\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qmatrix4x4\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qmatrix\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qmovie\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qoffscreensurface\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglbuffer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglcontext\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglframebufferobject\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_1_0\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_1_1\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_1_2\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_1_3\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_1_4\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_1_5\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_2_0\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_2_1\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_3_0\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_3_1\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_3_2_compatibility\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_3_2_core\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_3_3_compatibility\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_3_3_core\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_4_0_compatibility\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_4_0_core\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_4_1_compatibility\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_4_1_core\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_4_2_compatibility\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_4_2_core\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_4_3_compatibility\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_4_3_core\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglfunctions_es2\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglpaintdevice\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglpixeltransferoptions\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglshaderprogram\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopengltexture\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopengltimerquery\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglversionfunctions\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglvertexarrayobject\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qopenglwindow\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpagedpaintdevice\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpagelayout\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpagesize\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpaintdevice\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpaintdevicewindow\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpaintengine\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpainter\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpainterpath\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpalette\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpdfwriter\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpen\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpicture\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpictureformatplugin\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpixelformat\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpixmap\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpixmapcache\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qpolygon\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qquaternion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qrasterwindow\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qrawfont\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qregion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qrgb\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qscreen\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qsessionmanager\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qstandarditemmodel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qstatictext\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qstylehints\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qsurface\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qsurfaceformat\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qsyntaxhighlighter\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qtextcursor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qtextdocument\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qtextdocumentfragment\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qtextdocumentwriter\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qtextformat\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qtextlayout\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qtextlist\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qtextobject\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qtextoption\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qtexttable\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qtguiversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qtouchdevice\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qtransform\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qvalidator\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qvector2d\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qvector3d\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qvector4d\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtGui/)?qwindow\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtHelp/)?qhelpcontentwidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtHelp/)?qhelpengine\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtHelp/)?qhelpenginecore\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtHelp/)?qhelpindexwidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtHelp/)?qhelpsearchengine\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtHelp/)?qhelpsearchquerywidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtHelp/)?qhelpsearchresultwidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtHelp/)?qthelpversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qgeocodereply\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qgeocodingmanager\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qgeocodingmanagerengine\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qgeomaneuver\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qgeoroute\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qgeoroutereply\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qgeorouterequest\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qgeoroutesegment\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qgeoroutingmanager\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qgeoroutingmanagerengine\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qgeoserviceprovider\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qgeoserviceproviderfactory\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qlocation\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplace\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplaceattribute\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacecategory\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacecontactdetail\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacecontent\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacecontentreply\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacecontentrequest\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacedetailsreply\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplaceeditorial\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplaceicon\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplaceidreply\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplaceimage\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacemanager\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacemanagerengine\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacematchreply\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacematchrequest\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplaceproposedsearchresult\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplaceratings\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacereply\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplaceresult\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacereview\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacesearchreply\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacesearchrequest\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacesearchresult\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacesearchsuggestionreply\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplacesupplier\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qplaceuser\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtLocation/)?qtlocationversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qabstractvideobuffer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qabstractvideosurface\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qaudio\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qaudiobuffer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qaudiodecoder\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qaudiodecodercontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qaudiodeviceinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qaudioencodersettingscontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qaudioformat\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qaudioinput\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qaudioinputselectorcontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qaudiooutput\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qaudiooutputselectorcontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qaudioprobe\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qaudiorecorder\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qaudiosystemplugin\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcamera\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcameracapturebufferformatcontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcameracapturedestinationcontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcameracontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcameraexposure\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcameraexposurecontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcamerafeedbackcontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcameraflashcontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcamerafocus\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcamerafocuscontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcameraimagecapture\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcameraimagecapturecontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcameraimageprocessing\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcameraimageprocessingcontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcamerainfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcamerainfocontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcameralockscontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcameraviewfindersettingscontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qcamerazoomcontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qimageencodercontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediaaudioprobecontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediaavailabilitycontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediabindableinterface\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediacontainercontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediacontent\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediacontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediagaplessplaybackcontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediametadata\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmedianetworkaccesscontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediaobject\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediaplayer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediaplayercontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediaplaylist\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediarecorder\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediarecordercontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediaresource\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediaservice\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediaserviceproviderplugin\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediastreamscontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediatimerange\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmediavideoprobecontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmetadatareadercontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmetadatawritercontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qmultimedia\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qradiodata\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qradiodatacontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qradiotuner\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qradiotunercontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qsound\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qsoundeffect\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qtmultimediaversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qvideodeviceselectorcontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qvideoencodersettingscontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qvideoframe\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qvideoprobe\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qvideorenderercontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qvideosurfaceformat\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimedia/)?qvideowindowcontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimediaQuick_p/)?qsgvideonode_i420\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimediaQuick_p/)?qsgvideonode_rgb\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimediaQuick_p/)?qsgvideonode_texture\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimediaQuick_p/)?qtmultimediaquick_pversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimediaWidgets/)?qcameraviewfinder\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimediaWidgets/)?qgraphicsvideoitem\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimediaWidgets/)?qtmultimediawidgetsversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimediaWidgets/)?qvideowidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtMultimediaWidgets/)?qvideowidgetcontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qabstractnetworkcache\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qabstractsocket\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qauthenticator\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qdnslookup\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qhostaddress\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qhostinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qhttpmultipart\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qlocalserver\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qlocalsocket\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qnetworkaccessmanager\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qnetworkconfiguration\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qnetworkcookie\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qnetworkcookiejar\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qnetworkdiskcache\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qnetworkinterface\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qnetworkproxy\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qnetworkreply\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qnetworkrequest\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qnetworksession\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qssl\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qsslcertificate\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qsslcertificateextension\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qsslcipher\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qsslconfiguration\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qsslerror\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qsslkey\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qsslsocket\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qtcpserver\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qtcpsocket\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qtnetworkversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNetwork/)?qudpsocket\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNfc/)?qndeffilter\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNfc/)?qndefmessage\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNfc/)?qndefnfcsmartposterrecord\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNfc/)?qndefnfctextrecord\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNfc/)?qndefnfcurirecord\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNfc/)?qndefrecord\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNfc/)?qnearfieldmanager\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNfc/)?qnearfieldsharemanager\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNfc/)?qnearfieldsharetarget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNfc/)?qnearfieldtarget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNfc/)?qqmlndefrecord\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtNfc/)?qtnfcversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtOpenGL/)?qgl\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtOpenGL/)?qglbuffer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtOpenGL/)?qglcolormap\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtOpenGL/)?qglframebufferobject\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtOpenGL/)?qglfunctions\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtOpenGL/)?qglpixelbuffer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtOpenGL/)?qglshaderprogram\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtOpenGL/)?qtopenglversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtOpenGLExtensions/)?qopenglextensions\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtOpenGLExtensions/)?qtopenglextensionsversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPlatformHeaders/)?qcocoanativecontext\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPlatformHeaders/)?qeglfsfunctions\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPlatformHeaders/)?qeglnativecontext\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPlatformHeaders/)?qglxnativecontext\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPlatformHeaders/)?qtplatformheadersversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPlatformHeaders/)?qwglnativecontext\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPlatformHeaders/)?qxcbwindowfunctions\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPlatformSupport/)?qtplatformsupportversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPositioning/)?qgeoaddress\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPositioning/)?qgeoareamonitorinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPositioning/)?qgeoareamonitorsource\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPositioning/)?qgeocircle\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPositioning/)?qgeocoordinate\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPositioning/)?qgeolocation\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPositioning/)?qgeopositioninfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPositioning/)?qgeopositioninfosource\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPositioning/)?qgeopositioninfosourcefactory\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPositioning/)?qgeorectangle\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPositioning/)?qgeosatelliteinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPositioning/)?qgeosatelliteinfosource\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPositioning/)?qgeoshape\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPositioning/)?qnmeapositioninfosource\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPositioning/)?qtpositioningversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPrintSupport/)?qabstractprintdialog\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPrintSupport/)?qpagesetupdialog\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPrintSupport/)?qprintdialog\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPrintSupport/)?qprintengine\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPrintSupport/)?qprinter\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPrintSupport/)?qprinterinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPrintSupport/)?qprintpreviewdialog\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPrintSupport/)?qprintpreviewwidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtPrintSupport/)?qtprintsupportversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qjsengine\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qjsvalue\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qjsvalueiterator\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlabstracturlinterceptor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlapplicationengine\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlcomponent\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlcontext\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlengine\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlerror\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlexpression\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlextensioninterface\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlextensionplugin\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlfile\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlfileselector\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlincubator\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlnetworkaccessmanagerfactory\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlparserstatus\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlproperty\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlpropertymap\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlpropertyvaluesource\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qqmlscriptstring\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQml/)?qtqmlversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qquickframebufferobject\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qquickimageprovider\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qquickitem\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qquickitemgrabresult\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qquickpainteditem\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qquickrendercontrol\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qquicktextdocument\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qquickview\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qquickwindow\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qsgabstractrenderer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qsgengine\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qsgflatcolormaterial\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qsggeometry\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qsgmaterial\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qsgnode\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qsgsimplematerial\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qsgsimplerectnode\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qsgsimpletexturenode\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qsgtexture\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qsgtexturematerial\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qsgtextureprovider\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qsgvertexcolormaterial\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuick/)?qtquickversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuickParticles/)?qtquickparticlesversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuickTest/)?qtquicktestversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuickWidgets/)?qquickwidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtQuickWidgets/)?qtquickwidgetsversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtScript/)?qscriptable\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtScript/)?qscriptclass\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtScript/)?qscriptclasspropertyiterator\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtScript/)?qscriptcontext\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtScript/)?qscriptcontextinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtScript/)?qscriptengine\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtScript/)?qscriptengineagent\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtScript/)?qscriptextensioninterface\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtScript/)?qscriptextensionplugin\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtScript/)?qscriptprogram\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtScript/)?qscriptstring\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtScript/)?qscriptvalue\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtScript/)?qscriptvalueiterator\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtScript/)?qtscriptversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtScriptTools/)?qscriptenginedebugger\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtScriptTools/)?qtscripttoolsversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qaccelerometer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qaltimeter\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qambientlightsensor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qambienttemperaturesensor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qcompass\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qdistancesensor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qgyroscope\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qholstersensor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qirproximitysensor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qlightsensor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qmagnetometer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qorientationsensor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qpressuresensor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qproximitysensor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qrotationsensor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qsensor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qsensorbackend\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qsensorgesture\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qsensorgesturemanager\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qsensorgestureplugininterface\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qsensorgesturerecognizer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qsensormanager\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qtapsensor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qtiltsensor\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSensors/)?qtsensorsversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSerialPort/)?qlockfile\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSerialPort/)?qserialport\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSerialPort/)?qserialportinfo\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSerialPort/)?qtserialportversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSerialPort/)?qwineventnotifier\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSql/)?qsql\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSql/)?qsqldatabase\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSql/)?qsqldriver\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSql/)?qsqldriverplugin\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSql/)?qsqlerror\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSql/)?qsqlfield\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSql/)?qsqlindex\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSql/)?qsqlquery\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSql/)?qsqlquerymodel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSql/)?qsqlrecord\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSql/)?qsqlrelationaldelegate\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSql/)?qsqlrelationaltablemodel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSql/)?qsqlresult\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSql/)?qsqltablemodel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSql/)?qtsqlversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSvg/)?qgraphicssvgitem\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSvg/)?qsvggenerator\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSvg/)?qsvgrenderer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSvg/)?qsvgwidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtSvg/)?qtsvgversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtTest/)?qsignalspy\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtTest/)?qtest\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtTest/)?qtestdata\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtTest/)?qtestevent\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtTest/)?qtesteventloop\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtTest/)?qttestversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtUiTools/)?qtuitoolsversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtUiTools/)?quiloader\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebChannel/)?qqmlwebchannel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebChannel/)?qtwebchannelversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebChannel/)?qwebchannel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebChannel/)?qwebchannelabstracttransport\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebKit/)?qtwebkitversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebKit/)?qwebdatabase\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebKit/)?qwebelement\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebKit/)?qwebhistory\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebKit/)?qwebhistoryinterface\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebKit/)?qwebkitplatformplugin\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebKit/)?qwebpluginfactory\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebKit/)?qwebsecurityorigin\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebKit/)?qwebsettings\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebKitWidgets/)?qgraphicswebview\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebKitWidgets/)?qtwebkitwidgetsversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebKitWidgets/)?qwebframe\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebKitWidgets/)?qwebinspector\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebKitWidgets/)?qwebpage\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebKitWidgets/)?qwebview\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebSockets/)?qmaskgenerator\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebSockets/)?qtwebsocketsversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebSockets/)?qwebsocket\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebSockets/)?qwebsocketcorsauthenticator\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWebSockets/)?qwebsocketserver\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qabstractbutton\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qabstractitemdelegate\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qabstractitemview\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qabstractscrollarea\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qabstractslider\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qabstractspinbox\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qaccessiblemenu\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qaccessiblewidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qaction\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qactiongroup\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qapplication\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qboxlayout\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qbuttongroup\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qcalendarwidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qcheckbox\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qcolordialog\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qcolormap\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qcolumnview\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qcombobox\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qcommandlinkbutton\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qcommonstyle\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qcompleter\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qdatawidgetmapper\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qdatetimeedit\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qdesktopwidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qdial\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qdialog\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qdialogbuttonbox\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qdirmodel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qdockwidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qerrormessage\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qfiledialog\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qfileiconprovider\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qfilesystemmodel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qfocusframe\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qfontcombobox\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qfontdialog\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qformlayout\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qframe\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgesture\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgesturerecognizer\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgraphicsanchorlayout\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgraphicseffect\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgraphicsgridlayout\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgraphicsitem\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgraphicsitemanimation\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgraphicslayout\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgraphicslayoutitem\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgraphicslinearlayout\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgraphicsproxywidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgraphicsscene\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgraphicssceneevent\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgraphicstransform\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgraphicsview\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgraphicswidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgridlayout\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qgroupbox\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qheaderview\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qinputdialog\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qitemdelegate\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qitemeditorfactory\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qkeyeventtransition\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qkeysequenceedit\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qlabel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qlayout\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qlayoutitem\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qlcdnumber\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qlineedit\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qlistview\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qlistwidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qmainwindow\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qmdiarea\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qmdisubwindow\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qmenu\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qmenubar\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qmessagebox\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qmouseeventtransition\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qopenglwidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qplaintextedit\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qprogressbar\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qprogressdialog\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qproxystyle\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qpushbutton\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qradiobutton\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qrubberband\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qscrollarea\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qscrollbar\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qscroller\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qscrollerproperties\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qshortcut\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qsizegrip\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qsizepolicy\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qslider\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qspinbox\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qsplashscreen\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qsplitter\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qstackedlayout\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qstackedwidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qstatusbar\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qstyle\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qstyleditemdelegate\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qstylefactory\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qstyleoption\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qstylepainter\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qstyleplugin\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qsystemtrayicon\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qtabbar\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qtableview\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qtablewidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qtabwidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qtextbrowser\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qtextedit\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qtoolbar\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qtoolbox\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qtoolbutton\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qtooltip\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qtreeview\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qtreewidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qtreewidgetitemiterator\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qtwidgetsversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qundogroup\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qundostack\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qundoview\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qwhatsthis\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qwidget\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qwidgetaction\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWidgets/)?qwizard\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWinExtras/)?qtwinextrasversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWinExtras/)?qwinevent\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWinExtras/)?qwinjumplist\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWinExtras/)?qwinjumplistcategory\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWinExtras/)?qwinjumplistitem\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWinExtras/)?qwinmime\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWinExtras/)?qwintaskbarbutton\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWinExtras/)?qwintaskbarprogress\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWinExtras/)?qwinthumbnailtoolbar\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtWinExtras/)?qwinthumbnailtoolbutton\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtXml/)?qtxmlversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtXmlPatterns/)?qabstractmessagehandler\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtXmlPatterns/)?qabstracturiresolver\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtXmlPatterns/)?qabstractxmlnodemodel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtXmlPatterns/)?qabstractxmlreceiver\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtXmlPatterns/)?qsimplexmlnodemodel\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtXmlPatterns/)?qsourcelocation\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtXmlPatterns/)?qtxmlpatternsversion\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtXmlPatterns/)?qxmlformatter\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtXmlPatterns/)?qxmlname\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtXmlPatterns/)?qxmlnamepool\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtXmlPatterns/)?qxmlquery\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtXmlPatterns/)?qxmlresultitems\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtXmlPatterns/)?qxmlschema\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtXmlPatterns/)?qxmlschemavalidator\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtXmlPatterns/)?qxmlserializer\\.h\"", "private", "", "public" ] }, + { include: [ "@[\"<](ActiveQt/)?activeqtversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](ActiveQt/)?qaxaggregated\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](ActiveQt/)?qaxbase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](ActiveQt/)?qaxbindable\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](ActiveQt/)?qaxfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](ActiveQt/)?qaxobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](ActiveQt/)?qaxscript\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](ActiveQt/)?qaxselect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](ActiveQt/)?qaxwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Enginio/)?enginio\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](Enginio/)?enginioversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qbluetoothaddress\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qbluetoothdevicediscoveryagent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qbluetoothdeviceinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qbluetoothhostinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qbluetoothlocaldevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qbluetoothserver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qbluetoothservicediscoveryagent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qbluetoothserviceinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qbluetoothsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qbluetoothtransfermanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qbluetoothtransferreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qbluetoothtransferrequest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qbluetoothuuid\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qlowenergycharacteristic\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qlowenergycontroller\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qlowenergydescriptor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qlowenergyservice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtBluetooth/)?qtbluetoothversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCLucene/)?qtcluceneversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentfilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentrun\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtConcurrent/)?qtconcurrentversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractanimation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstracteventdispatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractitemmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractnativeeventfilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractproxymodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstractstate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qabstracttransition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qanimationgroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qarraydata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qarraydatapointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbasictimer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbitarray\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbytearray\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbytearraylist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qbytearraymatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qchar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcollator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcommandlineoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcommandlineparser\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcontiguouscache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcoreapplication\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qcryptographichash\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdatastream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdatetime\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdebug\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdir\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qdiriterator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qeasingcurve\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qelapsedtimer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qeventloop\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qeventtransition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qexception\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfactoryinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfile\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfiledevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfileinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfileselector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfilesystemwatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfinalstate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qflags\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfuture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfutureinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfuturesynchronizer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qfuturewatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qglobalstatic\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qhash\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qhistorystate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qidentityproxymodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qiodevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qitemselectionmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qjsonarray\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qjsondocument\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qjsonobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qjsonvalue\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlibrary\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlibraryinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qline\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlinkedlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlocale\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlockfile\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qloggingcategory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmargins\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmessageauthenticationcode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmetaobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmetatype\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmimedata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmimedatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmimetype\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qmutex\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qobjectcleanuphandler\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpair\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qparallelanimationgroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpauseanimation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpluginloader\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpoint\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qprocess\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qpropertyanimation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qqueue\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qreadwritelock\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qrect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qregexp\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qregularexpression\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qresource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qrunnable\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsavefile\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qscopedpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qscopedvaluerollback\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsemaphore\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsequentialanimationgroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qset\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsettings\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qshareddata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsharedmemory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsharedpointer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsignalmapper\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsignaltransition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsize\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsocketnotifier\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsortfilterproxymodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstack\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstandardpaths\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstatemachine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstorageinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstring\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringbuilder\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringlistmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qstringmatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsysinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qsystemsemaphore\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtcoreversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtemporarydir\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtemporaryfile\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtextboundaryfinder\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtextcodec\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtextstream\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qthread\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qthreadpool\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qthreadstorage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtimeline\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtimer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtimezone\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtranslator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qtypeinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qurl\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qurlquery\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?quuid\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvariant\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvariantanimation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvarlengtharray\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qvector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qwaitcondition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qwineventnotifier\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusabstractadaptor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusabstractinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusargument\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusconnection\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusconnectioninterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbuscontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbuserror\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusmessage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusmetatype\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbuspendingcall\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbuspendingreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusserver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusservicewatcher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusunixfiledescriptor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qdbusvirtualobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDBus/)?qtdbusversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativecomponent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativecontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativeengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativeerror\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativeexpression\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativeextensioninterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativeextensionplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativeimageprovider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativeinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativeitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativenetworkaccessmanagerfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativeparserstatus\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativeproperty\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativepropertymap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativepropertyvalueinterceptor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativepropertyvaluesource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativescriptstring\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qdeclarativeview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDeclarative/)?qtdeclarativeversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?qdesignerexportwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?qextensionmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesigner/)?qtdesignerversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtDesignerComponents/)?qtdesignercomponentsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qabstracttextdocumentlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessible\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessiblebridge\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessibleobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qaccessibleplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qbackingstore\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qbitmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qbrush\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qclipboard\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qcolor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qcursor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qdesktopservices\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qdrag\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qfont\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qfontdatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qfontinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qfontmetrics\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericmatrix\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qgenericpluginfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qglyphrun\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qguiapplication\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qicon\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qiconengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qiconengineplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qimage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qimageiohandler\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qimagereader\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qimagewriter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qinputmethod\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qkeysequence\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qmatrix4x4\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qmatrix\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qmovie\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qoffscreensurface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglbuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglcontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglframebufferobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_1_0\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_1_1\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_1_2\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_1_3\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_1_4\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_1_5\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_2_0\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_2_1\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_3_0\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_3_1\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_3_2_compatibility\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_3_2_core\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_3_3_compatibility\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_3_3_core\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_0_compatibility\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_0_core\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_1_compatibility\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_1_core\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_2_compatibility\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_2_core\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_3_compatibility\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_4_3_core\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglfunctions_es2\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglpaintdevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglpixeltransferoptions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglshaderprogram\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopengltexture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopengltimerquery\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglversionfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglvertexarrayobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qopenglwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpagedpaintdevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpagelayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpagesize\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpaintdevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpaintdevicewindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpaintengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpainter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpainterpath\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpalette\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpdfwriter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpen\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpicture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpictureformatplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpixelformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpixmap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpixmapcache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qpolygon\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qquaternion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qrasterwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qrawfont\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qregion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qrgb\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qscreen\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qsessionmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qstandarditemmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qstatictext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qstylehints\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qsurface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qsurfaceformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qsyntaxhighlighter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextcursor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextdocument\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextdocumentfragment\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextdocumentwriter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextlist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtextoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtexttable\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtguiversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtouchdevice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qtransform\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvalidator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvector2d\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvector3d\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qvector4d\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtGui/)?qwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpcontentwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpenginecore\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpindexwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpsearchengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpsearchquerywidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qhelpsearchresultwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtHelp/)?qthelpversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qgeocodereply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qgeocodingmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qgeocodingmanagerengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qgeomaneuver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qgeoroute\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qgeoroutereply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qgeorouterequest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qgeoroutesegment\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qgeoroutingmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qgeoroutingmanagerengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qgeoserviceprovider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qgeoserviceproviderfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qlocation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplace\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplaceattribute\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacecategory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacecontactdetail\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacecontent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacecontentreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacecontentrequest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacedetailsreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplaceeditorial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplaceicon\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplaceidreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplaceimage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacemanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacemanagerengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacematchreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacematchrequest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplaceproposedsearchresult\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplaceratings\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacereply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplaceresult\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacereview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacesearchreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacesearchrequest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacesearchresult\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacesearchsuggestionreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplacesupplier\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qplaceuser\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtLocation/)?qtlocationversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qabstractvideobuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qabstractvideosurface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qaudio\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qaudiobuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qaudiodecoder\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qaudiodecodercontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qaudiodeviceinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qaudioencodersettingscontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qaudioformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qaudioinput\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qaudioinputselectorcontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qaudiooutput\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qaudiooutputselectorcontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qaudioprobe\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qaudiorecorder\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qaudiosystemplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcamera\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcameracapturebufferformatcontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcameracapturedestinationcontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcameracontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcameraexposure\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcameraexposurecontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcamerafeedbackcontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcameraflashcontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcamerafocus\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcamerafocuscontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcameraimagecapture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcameraimagecapturecontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcameraimageprocessing\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcameraimageprocessingcontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcamerainfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcamerainfocontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcameralockscontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcameraviewfindersettingscontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qcamerazoomcontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qimageencodercontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediaaudioprobecontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediaavailabilitycontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediabindableinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediacontainercontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediacontent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediacontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediagaplessplaybackcontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediametadata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmedianetworkaccesscontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediaobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediaplayer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediaplayercontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediaplaylist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediarecorder\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediarecordercontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediaresource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediaservice\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediaserviceproviderplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediastreamscontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediatimerange\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmediavideoprobecontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmetadatareadercontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmetadatawritercontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qmultimedia\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qradiodata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qradiodatacontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qradiotuner\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qradiotunercontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qsound\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qsoundeffect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qtmultimediaversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qvideodeviceselectorcontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qvideoencodersettingscontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qvideoframe\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qvideoprobe\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qvideorenderercontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qvideosurfaceformat\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimedia/)?qvideowindowcontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimediaQuick_p/)?qsgvideonode_i420\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimediaQuick_p/)?qsgvideonode_rgb\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimediaQuick_p/)?qsgvideonode_texture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimediaQuick_p/)?qtmultimediaquick_pversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimediaWidgets/)?qcameraviewfinder\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimediaWidgets/)?qgraphicsvideoitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimediaWidgets/)?qtmultimediawidgetsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimediaWidgets/)?qvideowidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtMultimediaWidgets/)?qvideowidgetcontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qabstractnetworkcache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qabstractsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qauthenticator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qdnslookup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qhostaddress\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qhostinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qhttpmultipart\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qlocalserver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qlocalsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkaccessmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkconfiguration\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkcookie\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkcookiejar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkdiskcache\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkproxy\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkreply\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworkrequest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qnetworksession\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qssl\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslcertificate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslcertificateextension\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslcipher\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslconfiguration\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslerror\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslkey\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qsslsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qtcpserver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qtcpsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qtnetworkversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNetwork/)?qudpsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNfc/)?qndeffilter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNfc/)?qndefmessage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNfc/)?qndefnfcsmartposterrecord\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNfc/)?qndefnfctextrecord\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNfc/)?qndefnfcurirecord\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNfc/)?qndefrecord\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNfc/)?qnearfieldmanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNfc/)?qnearfieldsharemanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNfc/)?qnearfieldsharetarget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNfc/)?qnearfieldtarget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNfc/)?qqmlndefrecord\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtNfc/)?qtnfcversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qgl\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglbuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglcolormap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglframebufferobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglpixelbuffer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qglshaderprogram\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGL/)?qtopenglversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGLExtensions/)?qopenglextensions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtOpenGLExtensions/)?qtopenglextensionsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qcocoanativecontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qeglfsfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qeglnativecontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qglxnativecontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qtplatformheadersversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qwglnativecontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformHeaders/)?qxcbwindowfunctions\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPlatformSupport/)?qtplatformsupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeoaddress\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeoareamonitorinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeoareamonitorsource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeocircle\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeocoordinate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeolocation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeopositioninfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeopositioninfosource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeopositioninfosourcefactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeorectangle\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeosatelliteinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeosatelliteinfosource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qgeoshape\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qnmeapositioninfosource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPositioning/)?qtpositioningversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qabstractprintdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qpagesetupdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprintdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprintengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprinter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprinterinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprintpreviewdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qprintpreviewwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtPrintSupport/)?qtprintsupportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qjsengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qjsvalue\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qjsvalueiterator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlabstracturlinterceptor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlapplicationengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlcomponent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlcontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlerror\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlexpression\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlextensioninterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlextensionplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlfile\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlfileselector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlincubator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlnetworkaccessmanagerfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlparserstatus\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlproperty\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlpropertymap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlpropertyvaluesource\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qqmlscriptstring\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQml/)?qtqmlversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickframebufferobject\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickimageprovider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickitemgrabresult\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickpainteditem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickrendercontrol\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquicktextdocument\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qquickwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgabstractrenderer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgflatcolormaterial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsggeometry\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgmaterial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgsimplematerial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgsimplerectnode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgsimpletexturenode\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgtexture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgtexturematerial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgtextureprovider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qsgvertexcolormaterial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuick/)?qtquickversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuickParticles/)?qtquickparticlesversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuickTest/)?qtquicktestversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuickWidgets/)?qquickwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtQuickWidgets/)?qtquickwidgetsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtScript/)?qscriptable\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtScript/)?qscriptclass\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtScript/)?qscriptclasspropertyiterator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtScript/)?qscriptcontext\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtScript/)?qscriptcontextinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtScript/)?qscriptengine\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtScript/)?qscriptengineagent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtScript/)?qscriptextensioninterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtScript/)?qscriptextensionplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtScript/)?qscriptprogram\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtScript/)?qscriptstring\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtScript/)?qscriptvalue\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtScript/)?qscriptvalueiterator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtScript/)?qtscriptversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtScriptTools/)?qscriptenginedebugger\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtScriptTools/)?qtscripttoolsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qaccelerometer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qaltimeter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qambientlightsensor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qambienttemperaturesensor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qcompass\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qdistancesensor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qgyroscope\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qholstersensor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qirproximitysensor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qlightsensor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qmagnetometer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qorientationsensor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qpressuresensor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qproximitysensor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qrotationsensor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qsensor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qsensorbackend\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qsensorgesture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qsensorgesturemanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qsensorgestureplugininterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qsensorgesturerecognizer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qsensormanager\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qtapsensor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qtiltsensor\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSensors/)?qtsensorsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSerialPort/)?qlockfile\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSerialPort/)?qserialport\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSerialPort/)?qserialportinfo\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSerialPort/)?qtserialportversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSerialPort/)?qwineventnotifier\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsql\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqldatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqldriver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqldriverplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlerror\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlfield\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlindex\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlquery\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlquerymodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlrecord\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlrelationaldelegate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlrelationaltablemodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqlresult\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qsqltablemodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSql/)?qtsqlversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSvg/)?qgraphicssvgitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSvg/)?qsvggenerator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSvg/)?qsvgrenderer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSvg/)?qsvgwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtSvg/)?qtsvgversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qsignalspy\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtest\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtestdata\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtestevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qtesteventloop\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtTest/)?qttestversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtUiTools/)?qtuitoolsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtUiTools/)?quiloader\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebChannel/)?qqmlwebchannel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebChannel/)?qtwebchannelversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebChannel/)?qwebchannel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebChannel/)?qwebchannelabstracttransport\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qtwebkitversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebdatabase\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebelement\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebhistory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebhistoryinterface\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebkitplatformplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebpluginfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebsecurityorigin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKit/)?qwebsettings\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qgraphicswebview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qtwebkitwidgetsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qwebframe\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qwebinspector\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qwebpage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebKitWidgets/)?qwebview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebSockets/)?qmaskgenerator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebSockets/)?qtwebsocketsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebSockets/)?qwebsocket\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebSockets/)?qwebsocketcorsauthenticator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWebSockets/)?qwebsocketserver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractbutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractitemdelegate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractitemview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractscrollarea\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractslider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qabstractspinbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qaccessiblemenu\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qaccessiblewidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qaction\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qactiongroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qapplication\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qboxlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qbuttongroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcalendarwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcheckbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcolordialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcolormap\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcolumnview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcombobox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcommandlinkbutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcommonstyle\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qcompleter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdatawidgetmapper\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdatetimeedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdesktopwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdial\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdialogbuttonbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdirmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qdockwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qerrormessage\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfiledialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfileiconprovider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfilesystemmodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfocusframe\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfontcombobox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qfontdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qformlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qframe\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgesture\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgesturerecognizer\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsanchorlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicseffect\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsgridlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsitemanimation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicslayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicslayoutitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicslinearlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsproxywidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsscene\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicssceneevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicstransform\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicsview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgraphicswidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgridlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qgroupbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qheaderview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qinputdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qitemdelegate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qitemeditorfactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qkeyeventtransition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qkeysequenceedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlabel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlayoutitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlcdnumber\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlineedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlistview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qlistwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmainwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmdiarea\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmdisubwindow\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmenu\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmenubar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmessagebox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qmouseeventtransition\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qopenglwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qplaintextedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qprogressbar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qprogressdialog\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qproxystyle\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qpushbutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qradiobutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qrubberband\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qscrollarea\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qscrollbar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qscroller\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qscrollerproperties\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qshortcut\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qsizegrip\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qsizepolicy\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qslider\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qspinbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qsplashscreen\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qsplitter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstackedlayout\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstackedwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstatusbar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyle\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleditemdelegate\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstylefactory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleoption\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstylepainter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qstyleplugin\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qsystemtrayicon\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtabbar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtableview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtablewidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtabwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtextbrowser\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtextedit\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtoolbar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtoolbox\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtoolbutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtooltip\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtreeview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtreewidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtreewidgetitemiterator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qtwidgetsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qundogroup\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qundostack\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qundoview\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qwhatsthis\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qwidget\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qwidgetaction\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWidgets/)?qwizard\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWinExtras/)?qtwinextrasversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWinExtras/)?qwinevent\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWinExtras/)?qwinjumplist\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWinExtras/)?qwinjumplistcategory\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWinExtras/)?qwinjumplistitem\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWinExtras/)?qwinmime\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWinExtras/)?qwintaskbarbutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWinExtras/)?qwintaskbarprogress\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWinExtras/)?qwinthumbnailtoolbar\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtWinExtras/)?qwinthumbnailtoolbutton\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXml/)?qtxmlversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qabstractmessagehandler\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qabstracturiresolver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qabstractxmlnodemodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qabstractxmlreceiver\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qsimplexmlnodemodel\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qsourcelocation\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qtxmlpatternsversion\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlformatter\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlname\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlnamepool\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlquery\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlresultitems\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlschema\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlschemavalidator\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtXmlPatterns/)?qxmlserializer\\.h[\">]", "private", "", "public" ] }, # And lastly, things stored in difficult places - { include: [ "@\"(QtCore/)?qobjectdefs\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qglobal\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qnamespace\\.h\"", "private", "", "public" ] }, - { include: [ "@\"(QtCore/)?qlogging\\.h\"", "private", "", "public" ] }, #qDebug, qWarning, etc - { include: [ "@\"(QtCore/)?qalgorithms\\.h\"", "private", "", "public" ] }, #qSort, etc - { include: [ "@\"(QtWinExtras/)?qwinfunctions\\.h\"", "private", "", "public" ] }, # for fromHICON + { include: [ "@[\"<](QtCore/)?qobjectdefs\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qglobal\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qnamespace\\.h[\">]", "private", "", "public" ] }, + { include: [ "@[\"<](QtCore/)?qlogging\\.h[\">]", "private", "", "public" ] }, #qDebug, qWarning, etc + { include: [ "@[\"<](QtCore/)?qalgorithms\\.h[\">]", "private", "", "public" ] }, #qSort, etc + { include: [ "@[\"<](QtWinExtras/)?qwinfunctions\\.h[\">]", "private", "", "public" ] }, # for fromHICON # These ones are just madness. For instance, why with the above do we get # #include "QtCore/qcoreevent.h" // for QEvent (ptr only), etc diff --git a/run_iwyu_tests.py b/run_iwyu_tests.py index 5cdba9c..a566949 100755 --- a/run_iwyu_tests.py +++ b/run_iwyu_tests.py @@ -73,6 +73,7 @@ class OneIwyuTest(unittest.TestCase): 'keep_includes.c': ['--keep=tests/c/keep_includes*.h'], 'keep_mapping.cc': [self.CheckAlsoExtension('-public.h'), self.MappingFile('keep_mapping.imp')], + 'keep_moc.cc': [self.CheckAlsoExtension('-i1.h')], 'macro_location.cc': [self.CheckAlsoExtension('-d2.h')], 'mapping_to_self.cc': [self.MappingFile('mapping_to_self.imp')], 'non_transitive_include.cc': [self.CheckAlsoExtension('-d*.h'), @@ -88,6 +89,8 @@ class OneIwyuTest(unittest.TestCase): 'prefix_header_includes_remove.cc': ['--prefix_header_includes=remove'], 'prefix_header_operator_new.cc': ['--prefix_header_includes=remove'], 'quoted_includes_first.cc': ['--pch_in_code', '--quoted_includes_first'], + 'relative_exported_mapped_include.cc': + [self.MappingFile('relative_exported_mapped_include.imp')], 'cxx17ns.cc': ['--cxx17ns'], } prefix_headers = [self.Include('prefix_header_includes-d1.h'), @@ -110,6 +113,8 @@ class OneIwyuTest(unittest.TestCase): self.Include('macro_defined_by_includer-prefix.h')], 'macro_location.cc': ['-Wno-sizeof-pointer-div'], 'ms_inline_asm.cc': ['-fms-extensions'], + 'operator_new.cc': ['-std=c++17'], + 'placement_new.cc': ['-std=c++17'], 'prefix_header_attribution.cc': [self.Include('prefix_header_attribution-d1.h')], 'prefix_header_includes_add.cc': prefix_headers, 'prefix_header_includes_keep.cc': prefix_headers, @@ -124,9 +129,11 @@ class OneIwyuTest(unittest.TestCase): 'array.cc': ['.'], 'associated_h_file_heuristic.cc': ['.'], 'associated_include.cc': ['.'], + 'associated_skipped.cc': ['.'], 'backwards_includes.cc': ['.'], 'badinc.cc': ['.'], 'badinc-extradef.cc': ['.'], + 'binary_type_trait.cc': ['.'], 'builtins_with_mapping.cc': ['.'], 'funcptrs.cc': ['.'], 'casts.cc': ['.'], @@ -140,24 +147,29 @@ class OneIwyuTest(unittest.TestCase): 'default_template_arg_other_file.cc': ['.'], 'depopulated_h_file.cc': ['.'], 'derived_function_tpl_args.cc': ['.'], + 'dotdot.cc': ['.'], 'double_include.cc': ['.'], 'elaborated_struct.c': ['.'], 'elaborated_type.cc': ['.'], + 'enum_base.cc': ['.'], 'export_nesting.cc': ['.'], 'external_including_internal.cc': ['.'], 'forward_declare_in_macro.cc': ['.'], 'fullinfo_for_templates.cc': ['.'], 'fwd_decl_class_template.cc': ['.'], + 'fwd_decl_final.cc': ['.'], 'fwd_decl_static_member.cc': ['.'], 'fwd_decl_with_instantiation.cc': ['.'], - 'header_in_subfolder.cc': ['.'], + 'header_in_subdir.cc': ['.'], 'implicit_ctor.cc': ['.'], 'include_cycle.cc': ['.'], 'include_with_using.cc': ['.'], + 'inline_namespace.cc': ['.'], 'internal/internal_files.cc': ['.'], 'iwyu_stricter_than_cpp.cc': ['.'], 'keep_includes.c': ['.'], 'keep_mapping.cc': ['.'], + 'keep_moc.cc': ['.'], 'lateparsed_template.cc': ['.'], 'macro_defined_by_includer.cc': ['.'], 'macro_location.cc': ['.'], @@ -170,9 +182,11 @@ class OneIwyuTest(unittest.TestCase): 'no_fwd_decls.cc': ['.'], 'no_h_includes_cc.cc': ['.'], 'non_transitive_include.cc': ['.'], + 'operator_new.cc': ['.'], 'overloaded_class.cc': ['.'], 'pch_in_code.cc': ['.'], 'pointer_arith.cc': ['.'], + 'placement_new.cc': ['.'], 'pragma_associated.cc': ['.'], 'precomputed_tpl_args.cc': ['.'], 'prefix_header_attribution.cc': ['.'], @@ -183,8 +197,10 @@ class OneIwyuTest(unittest.TestCase): 'range_for.cc': ['.'], 're_fwd_decl.cc': ['.'], 'redecls.cc': ['.'], + 'relative_exported_mapped_include.cc': ['tests/cxx/subdir'], 'remove_fwd_decl_when_including.cc': ['.'], 'self_include.cc': ['.'], + 'sizeof_in_template_arg.cc': ['.'], 'sizeof_reference.cc': ['.'], 'specialization_needs_decl.cc': ['.'], 'system_namespaces.cc': ['.'], diff --git a/scrub-logs.py b/scrub-logs.py index d314862..b289ea3 100755 --- a/scrub-logs.py +++ b/scrub-logs.py @@ -1,8 +1,8 @@ #!/usr/bin/env python -##===---------- scrub-logs.py - generate README from Wiki sources ---------===## +##===--- scrub-logs.py - generate README from Wiki sources ----------------===## # -# The LLVM Compiler Infrastructure +# The LLVM Compiler Infrastructure # # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. diff --git a/tests/c/elaborated_struct.c b/tests/c/elaborated_struct.c index 4aa1088..f12fde7 100644 --- a/tests/c/elaborated_struct.c +++ b/tests/c/elaborated_struct.c @@ -21,6 +21,11 @@ typedef struct TypedeffedStruct TypedeffedStruct; // No diagnostic expected. // that an explicit forward declaration would be better. int UseStruct(struct Struct* s); +// If an existing forward-declaration is available, make sure we don't suggest +// adding it twice (see issue #682). +struct ForwardDeclared; +void UseForwardDeclared(struct ForwardDeclared*); + /**** IWYU_SUMMARY tests/c/elaborated_struct.c should add these lines: @@ -30,6 +35,7 @@ tests/c/elaborated_struct.c should remove these lines: - #include "tests/c/elaborated_struct-d1.h" // lines XX-XX The full include-list for tests/c/elaborated_struct.c: +struct ForwardDeclared; // lines XX-XX struct Struct; ***** IWYU_SUMMARY */ diff --git a/tests/cxx/alias_template.cc b/tests/cxx/alias_template.cc index e25032b..1c9f896 100644 --- a/tests/cxx/alias_template.cc +++ b/tests/cxx/alias_template.cc @@ -11,19 +11,19 @@ #include "tests/cxx/direct.h" -template struct FullUseTemplateArg { +template struct FullUseTemplateArgInSizeof { char argument[sizeof(T)]; }; // Test that we go through alias template and handle aliased template // specialization. -template using Alias = FullUseTemplateArg; +template using Alias = FullUseTemplateArgInSizeof; // IWYU: IndirectClass needs a declaration // IWYU: IndirectClass is...*indirect.h Alias alias; // Test following through entire chain of aliases. -template using AliasChain1 = FullUseTemplateArg; +template using AliasChain1 = FullUseTemplateArgInSizeof; template using AliasChain2 = AliasChain1; // IWYU: IndirectClass needs a declaration // IWYU: IndirectClass is...*indirect.h @@ -33,6 +33,25 @@ AliasChain2 aliasChain; template using Pointer = T*; Pointer intPtr; +template +struct FullUseTemplateArgAsVar { + T t; +}; + +// Test the used class being nested deeper in the alias +template +using AliasNested = FullUseTemplateArgAsVar>; + +// IWYU: IndirectClass needs a declaration +// IWYU: IndirectClass is...*indirect.h +AliasNested aliasNested; + +template +using AliasNested2 = FullUseTemplateArgInSizeof>; +// IWYU: IndirectClass needs a declaration +// IWYU: IndirectClass is...*indirect.h +AliasNested2 aliasNested2; + /**** IWYU_SUMMARY tests/cxx/alias_template.cc should add these lines: diff --git a/tests/cxx/alias_template_use-d1.h b/tests/cxx/alias_template_use-d1.h new file mode 100644 index 0000000..7c5f333 --- /dev/null +++ b/tests/cxx/alias_template_use-d1.h @@ -0,0 +1,10 @@ +//===--- alias_template_use-d1.h - test input file for iwyu ---------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "alias_template_use-i1.h" diff --git a/tests/cxx/alias_template_use-i1.h b/tests/cxx/alias_template_use-i1.h new file mode 100644 index 0000000..bf28969 --- /dev/null +++ b/tests/cxx/alias_template_use-i1.h @@ -0,0 +1,14 @@ +//===--- alias_template_use-i1.h - test input file for iwyu ---------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "alias_template_use-i2.h" + +template +using AliasTemplate = AliasedTemplate; + diff --git a/tests/cxx/alias_template_use-i2.h b/tests/cxx/alias_template_use-i2.h new file mode 100644 index 0000000..fee40b8 --- /dev/null +++ b/tests/cxx/alias_template_use-i2.h @@ -0,0 +1,11 @@ +//===--- alias_template_use-i2.h - test input file for iwyu ---------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +template +class AliasedTemplate {}; diff --git a/tests/cxx/alias_template_use.cc b/tests/cxx/alias_template_use.cc new file mode 100644 index 0000000..51c38bb --- /dev/null +++ b/tests/cxx/alias_template_use.cc @@ -0,0 +1,35 @@ +//===--- alias_template_use.cc - test input file for iwyu -----------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Tests that use of template aliases is assigned to the header defining the +// alias, rather than the underlying type. + +#include "alias_template_use-d1.h" + +template +class A { +}; + +class B { + // IWYU: AliasTemplate is...*alias_template_use-i1.h + A> a; +}; + +/**** IWYU_SUMMARY + +tests/cxx/alias_template_use.cc should add these lines: +#include "alias_template_use-i1.h" + +tests/cxx/alias_template_use.cc should remove these lines: +- #include "alias_template_use-d1.h" // lines XX-XX + +The full include-list for tests/cxx/alias_template_use.cc: +#include "alias_template_use-i1.h" // for AliasTemplate + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/associated_skipped-d1.h b/tests/cxx/associated_skipped-d1.h new file mode 100644 index 0000000..2b696a3 --- /dev/null +++ b/tests/cxx/associated_skipped-d1.h @@ -0,0 +1,10 @@ +//===--- associated_skipped-d1.h - test input file for iwyu ---------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "tests/cxx/associated_skipped-i1.h" diff --git a/tests/cxx/associated_skipped-i1.h b/tests/cxx/associated_skipped-i1.h new file mode 100644 index 0000000..0b202c5 --- /dev/null +++ b/tests/cxx/associated_skipped-i1.h @@ -0,0 +1,17 @@ +//===--- associated_skipped-i1.h - test input file for iwyu ---------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_ASSOCIATED_SKIPPED_I1_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_ASSOCIATED_SKIPPED_I1_H_ + +static inline int quad(int v) { + return v * 4; +} + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_ASSOCIATED_SKIPPED_I1_H_ diff --git a/tests/cxx/associated_skipped.cc b/tests/cxx/associated_skipped.cc new file mode 100644 index 0000000..3465ce1 --- /dev/null +++ b/tests/cxx/associated_skipped.cc @@ -0,0 +1,59 @@ +//===--- associated_skipped.cc - test input file for iwyu -----------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// This is a half-way test. It lays out an include graph that would cause an +// assertion failure in IWYU (issue #738): +// +// * Main file includes the associated header by two different include names +// * The first include is not classified as an associated header +// * The second is, but is skipped due to include guards +// +// This would add the associated header to the include graph, but not to the set +// of headers to be checked for IWYU, which eventually led to the assertion +// failure. This has since been fixed. +// +// Unfortunately this problem only triggers if IWYU is invoked with an absolute +// path, and the current test framework doesn't support that, so this test would +// not trigger the problem before the patch. +// +// And it also triggers another canonicalization problem, where tests/cxx/x.h +// and x.h are not seen as the same header, so the expected results are not +// strictly ideal (both tests/cxx/associated_skipped.h and associated_skipped.h +// are retained). +// +// But it seems valuable to keep this scenario around when making changes to +// this logic, to make sure it doesn't regress even further. + +#include "tests/cxx/associated_skipped-d1.h" +#include "tests/cxx/associated_skipped.h" +#include "associated_skipped.h" + +int main() { + // twice is in the associated header, which is already present, so + // no diagnostic expected. + int x = twice(4); + + // IWYU: quad is...*associated_skipped-i1.h + return quad(2); +} + +/**** IWYU_SUMMARY + +tests/cxx/associated_skipped.cc should add these lines: +#include "tests/cxx/associated_skipped-i1.h" + +tests/cxx/associated_skipped.cc should remove these lines: +- #include "tests/cxx/associated_skipped-d1.h" // lines XX-XX + +The full include-list for tests/cxx/associated_skipped.cc: +#include "tests/cxx/associated_skipped.h" +#include "associated_skipped.h" // for twice +#include "tests/cxx/associated_skipped-i1.h" // for quad + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/associated_skipped.h b/tests/cxx/associated_skipped.h new file mode 100644 index 0000000..d50902d --- /dev/null +++ b/tests/cxx/associated_skipped.h @@ -0,0 +1,23 @@ +//===--- associated_skipped.h - test input file for iwyu ------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_ASSOCIATED_SKIPPED_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_ASSOCIATED_SKIPPED_H_ + +static inline int twice(int v) { + return v * 2; +} + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_ASSOCIATED_SKIPPED_H_ + +/**** IWYU_SUMMARY + +(tests/cxx/associated_skipped.h has correct #includes/fwd-decls) + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/badinc.cc b/tests/cxx/badinc.cc index 139558f..8c62bc0 100644 --- a/tests/cxx/badinc.cc +++ b/tests/cxx/badinc.cc @@ -388,19 +388,6 @@ template void CallOverloadWithUsingShadowDecl(T t) { I1_NamespaceTemplateFn(t); } -template void CallPlacementNew(T t) { - static char buffer[sizeof(t)]; - // These should all be iwyu violations here, even though we can't be - // *sure* some of these are actually placment-new until we get a - // specific type for T (at template-instantiation time). - // IWYU: operator new is...* - new (&t) int; - // IWYU: operator new is...* - new (buffer) T(); - // IWYU: operator new is...* - new (&t) T(); -} - // This is defining a class declared in badinc-i1.h, but I think it's // correct that it's not an IWYU violation to leave out badinc-i1.h. class I1_DefinedInCc_Class { @@ -1178,8 +1165,6 @@ int main() { CallOverloadedFunctionDifferentFiles(5.0f); // This should not be an IWYU violation either: the iwyu use is in the fn. CallOverloadWithUsingShadowDecl(5); - // IWYU: I1_Class is...*badinc-i1.h - CallPlacementNew(i1_class); // Calling operator<< when the first argument is a macro. We should // still detect that operator<< is being used here, and not in the @@ -1554,28 +1539,16 @@ int main() { std::list* list_ptr; list_ptr = 0; - // Make sure we only report an iwyu for because of placement-new. - // We also need to check the argument to new. - int* newed_int = new int; - // IWYU: operator new is...* - new(newed_int) int(4); // IWYU: std::vector is...* // IWYU: I2_Enum is...*badinc-i2.h std::vector* newed_vector // IWYU: std::vector is...* // IWYU: I2_Enum is...*badinc-i2.h = new std::vector; - // IWYU: i1_i1_classptr is...*badinc-i1.h - // IWYU: I1_Class is...*badinc-i1.h - // IWYU: kI1ConstInt is...*badinc-i1.h - // IWYU: operator new is...* - new (i1_i1_classptr) I1_Class(kI1ConstInt); // IWYU: I1_Class needs a declaration // IWYU: I1_Class is...*badinc-i1.h // IWYU: kI1ConstInt is...*badinc-i1.h I1_Class* newed_i1_class_array = new I1_Class[kI1ConstInt]; - delete newed_int; - delete (((newed_int))); // TODO(csilvers): IWYU: I2_Enum is...*badinc-i2.h // IWYU: std::vector is...* delete newed_vector; @@ -1620,24 +1593,6 @@ int main() { // IWYU: I2_Class needs a declaration // IWYU: I2_Class is...*badinc-i2.h = new I1_TemplateClass(i1_union); - // IWYU: I1_TemplateClass is...*badinc-i1.h - // IWYU: I2_Class needs a declaration - // IWYU: I2_Class is...*badinc-i2.h - // IWYU: I1_Struct needs a declaration - char i1_templateclass_storage[sizeof(I1_TemplateClass)]; - // We need full type info for i1_templateclass because we never - // fwd-declare a class with default template parameters. - // IWYU: I1_TemplateClass is...*badinc-i1.h - // IWYU: I2_Class needs a declaration - // IWYU: I1_Struct needs a declaration - I1_TemplateClass* placement_newed_i1_template_class - // IWYU: I1_Struct needs a declaration - // IWYU: I1_Struct is...*badinc-i1.h - // IWYU: I1_TemplateClass is...*badinc-i1.h - // IWYU: I2_Class needs a declaration - // IWYU: I2_Class is...*badinc-i2.h - // IWYU: operator new is...* - = new(i1_templateclass_storage) I1_TemplateClass(); // IWYU: I1_Class needs a declaration // IWYU: I1_Class is...*badinc-i1.h // IWYU: i1_ns::I1_NamespaceClass is...*badinc-i1.h @@ -1658,11 +1613,6 @@ int main() { // IWYU: I1_Struct is...*badinc-i1.h // IWYU: I1_TemplateClass is...*badinc-i1.h delete newed_i1_template_class_ctor; - // Make sure we handle it right when we explicitly call the dtor, as well. - // IWYU: I2_Class::~I2_Class is...*badinc-i2-inl.h - // IWYU: I1_TemplateClass is...*badinc-i1.h - // IWYU: I1_Struct is...*badinc-i1.h - placement_newed_i1_template_class->~I1_TemplateClass(); // IWYU: I1_Class is...*badinc-i1.h delete i1_class_tpl_ctor; // Check that we discover constructor/destructor locations as well. @@ -1751,7 +1701,6 @@ int main() { // IWYU: std::vector<.*>::const_iterator is...* const std::vector::const_iterator float_constit = float_vector.begin(); // IWYU: std::vector is...* - // IWYU: std::vector<.*>::const_iterator is...* (void)(float_it == float_constit); // IWYU: std::vector is...* // IWYU: std::vector<.*>::const_iterator is...* @@ -1776,7 +1725,6 @@ int main() { // IWYU: std::vector is...* float_reverse_it = float_vector.rbegin(); // IWYU: std::vector is...* - // IWYU: std::vector<.*>::reverse_iterator is...* float_reverse_it != float_vector.rbegin(); // IWYU: std::vector is...* // IWYU: std::vector<.*>::reverse_iterator is...* @@ -1790,7 +1738,6 @@ int main() { // IWYU: std::vector is...* float_const_reverse_it = float_vector.rbegin(); // IWYU: std::vector is...* - // IWYU: std::vector<.*>::const_reverse_iterator is...* float_const_reverse_it != float_vector.rend(); // IWYU: std::vector is...* // IWYU: std::vector<.*>::const_reverse_iterator is...* @@ -1864,10 +1811,6 @@ int main() { I1_TemplateFunction(i1_class_ptr); // Try again, but with a typedef Cc_typedef cc_typedef; - // TODO(csilvers): figure out the template arg here is really a - // typedef (tricky because we need to call the I1_Class ctor), - // and don't add it to tpl-types-of-interest. - // IWYU: I1_Class is...*badinc-i1.h // IWYU: I1_TemplateFunction is...*badinc-i1.h I1_TemplateFunction(cc_typedef); // IWYU: I1_TemplateFunction is...*badinc-i1.h @@ -1917,7 +1860,6 @@ tests/cxx/badinc.cc should add these lines: #include #include #include -#include #include "tests/cxx/badinc-i1.h" class D2_Class; class D2_ForwardDeclareClass; @@ -1950,12 +1892,11 @@ The full include-list for tests/cxx/badinc.cc: #include // for find #include // for fstream #include // for list -#include // for operator new #include // for basic_string, basic_string<>::iterator, operator+, string #include // for type_info #include "tests/cxx/badinc-d1.h" // for D11, D1CopyClassFn, D1Function, D1_Class, D1_CopyClass, D1_Enum, D1_I1_Typedef, D1_StructPtr, D1_Subclass, D1_TemplateClass, D1_TemplateStructWithDefaultParam, MACRO_CALLING_I4_FUNCTION #include "tests/cxx/badinc-d4.h" // for D4_ClassForOperator, operator<< -#include "tests/cxx/badinc-i1.h" // for EmptyDestructorClass, H_Class::H_Class_DefinedInI1, I11, I12, I13, I1_And_I2_OverloadedFunction, I1_Base, I1_Class, I1_Class::NestedStruct, I1_ClassPtr, I1_Enum, I1_Function, I1_FunctionPtr, I1_I2_Class_Typedef, I1_MACRO_LOGGING_CLASS, I1_MACRO_SYMBOL_WITHOUT_VALUE, I1_MACRO_SYMBOL_WITH_VALUE, I1_MACRO_SYMBOL_WITH_VALUE0, I1_MACRO_SYMBOL_WITH_VALUE2, I1_ManyPtrStruct (ptr only), I1_MemberPtr, I1_NamespaceClass, I1_NamespaceStruct, I1_NamespaceTemplateFn, I1_OverloadedFunction, I1_PtrAndUseOnSameLine, I1_PtrDereferenceClass, I1_PtrDereferenceStatic, I1_PtrDereferenceStruct, I1_SiblingClass, I1_StaticMethod, I1_Struct, I1_Subclass, I1_SubclassesI2Class, I1_TemplateClass, I1_TemplateClass<>::I1_TemplateClass_int, I1_TemplateClassFwdDeclaredInD2 (ptr only), I1_TemplateFunction, I1_TemplateMethodOnlyClass, I1_TemplateSubclass, I1_Typedef, I1_TypedefOnly_Class, I1_TypedefOnly_Class<>::i, I1_Union, I1_UnnamedStruct, I1_UnusedNamespaceStruct (ptr only), I1_const_ptr, I2_OperatorDefinedInI1Class::operator<<, MACRO_CALLING_I6_FUNCTION, OperateOn, i1_GlobalFunction, i1_i1_classptr, i1_int, i1_int_global, i1_int_global2, i1_int_global2sub, i1_int_global3, i1_int_global3sub, i1_int_global4, i1_int_global4sub, i1_int_globalsub, i1_ns2, i1_ns4, i1_ns5, kI1ConstInt, operator== +#include "tests/cxx/badinc-i1.h" // for EmptyDestructorClass, H_Class::H_Class_DefinedInI1, I11, I12, I13, I1_And_I2_OverloadedFunction, I1_Base, I1_Class, I1_Class::NestedStruct, I1_ClassPtr, I1_Enum, I1_Function, I1_FunctionPtr, I1_I2_Class_Typedef, I1_MACRO_LOGGING_CLASS, I1_MACRO_SYMBOL_WITHOUT_VALUE, I1_MACRO_SYMBOL_WITH_VALUE, I1_MACRO_SYMBOL_WITH_VALUE0, I1_MACRO_SYMBOL_WITH_VALUE2, I1_ManyPtrStruct (ptr only), I1_MemberPtr, I1_NamespaceClass, I1_NamespaceStruct, I1_NamespaceTemplateFn, I1_OverloadedFunction, I1_PtrAndUseOnSameLine, I1_PtrDereferenceClass, I1_PtrDereferenceStatic, I1_PtrDereferenceStruct, I1_SiblingClass, I1_StaticMethod, I1_Struct, I1_Subclass, I1_SubclassesI2Class, I1_TemplateClass, I1_TemplateClass<>::I1_TemplateClass_int, I1_TemplateClassFwdDeclaredInD2 (ptr only), I1_TemplateFunction, I1_TemplateMethodOnlyClass, I1_TemplateSubclass, I1_Typedef, I1_TypedefOnly_Class, I1_TypedefOnly_Class<>::i, I1_Union, I1_UnnamedStruct, I1_UnusedNamespaceStruct (ptr only), I1_const_ptr, I2_OperatorDefinedInI1Class::operator<<, MACRO_CALLING_I6_FUNCTION, OperateOn, i1_GlobalFunction, i1_int, i1_int_global, i1_int_global2, i1_int_global2sub, i1_int_global3, i1_int_global3sub, i1_int_global4, i1_int_global4sub, i1_int_globalsub, i1_ns2, i1_ns4, i1_ns5, kI1ConstInt, operator== #include "tests/cxx/badinc2.c" class D2_Class; class D2_ForwardDeclareClass; diff --git a/tests/cxx/binary_type_trait-d1.h b/tests/cxx/binary_type_trait-d1.h new file mode 100644 index 0000000..09247f8 --- /dev/null +++ b/tests/cxx/binary_type_trait-d1.h @@ -0,0 +1,15 @@ +//===--- binary_type_trait-d1.h - test input file for iwyu ----------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_BINARY_TYPE_TRAIT_D1_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_BINARY_TYPE_TRAIT_D1_H_ + +#include "tests/cxx/binary_type_trait-i2.h" + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_BINARY_TYPE_TRAIT_D1_H_ diff --git a/tests/cxx/binary_type_trait-i1.h b/tests/cxx/binary_type_trait-i1.h new file mode 100644 index 0000000..76faddd --- /dev/null +++ b/tests/cxx/binary_type_trait-i1.h @@ -0,0 +1,15 @@ +//===--- binary_type_trait-i1.h - test input file for iwyu ----------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_BINARY_TYPE_TRAIT_I1_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_BINARY_TYPE_TRAIT_I1_H_ + +class BinaryTypeTraitBase {}; + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_BINARY_TYPE_TRAIT_I1_H_ diff --git a/tests/cxx/binary_type_trait-i2.h b/tests/cxx/binary_type_trait-i2.h new file mode 100644 index 0000000..65e82f4 --- /dev/null +++ b/tests/cxx/binary_type_trait-i2.h @@ -0,0 +1,17 @@ +//===--- binary_type_trait-i2.h - test input file for iwyu ----------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_BINARY_TYPE_TRAIT_I2_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_BINARY_TYPE_TRAIT_I2_H_ + +#include "tests/cxx/binary_type_trait-i1.h" + +class BinaryTypeTraitDerived : public BinaryTypeTraitBase {}; + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_BINARY_TYPE_TRAIT_I2_H_ diff --git a/tests/cxx/binary_type_trait.cc b/tests/cxx/binary_type_trait.cc new file mode 100644 index 0000000..a017e48 --- /dev/null +++ b/tests/cxx/binary_type_trait.cc @@ -0,0 +1,48 @@ +//===--- binary_type_trait.cc - test input file for iwyu ------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "tests/cxx/binary_type_trait-d1.h" + +int main() { + // IWYU: BinaryTypeTraitBase is...*binary_type_trait-i1.h + // IWYU: BinaryTypeTraitBase needs a declaration + // IWYU: BinaryTypeTraitDerived is...*binary_type_trait-i2.h + // IWYU: BinaryTypeTraitDerived needs a declaration + static_assert(__is_convertible_to(BinaryTypeTraitDerived*, BinaryTypeTraitBase*), + "Derived should be convertible to the Base class"); + + // IWYU: BinaryTypeTraitBase is...*binary_type_trait-i1.h + // IWYU: BinaryTypeTraitBase needs a declaration + // IWYU: BinaryTypeTraitDerived is...*binary_type_trait-i2.h + // IWYU: BinaryTypeTraitDerived needs a declaration + static_assert(!__is_convertible_to(BinaryTypeTraitDerived**, BinaryTypeTraitBase**), + "Indirect pointers shouldn't be convertible"); + + // IWYU: BinaryTypeTraitBase is...*binary_type_trait-i1.h + // IWYU: BinaryTypeTraitBase needs a declaration + // IWYU: BinaryTypeTraitDerived is...*tests/cxx/binary_type_trait-i2.h + // IWYU: BinaryTypeTraitDerived needs a declaration + static_assert(__is_convertible_to(BinaryTypeTraitDerived&, BinaryTypeTraitBase&), + "Derived should be convertible to the Base class"); +} + +/**** IWYU_SUMMARY + +tests/cxx/binary_type_trait.cc should add these lines: +#include "tests/cxx/binary_type_trait-i1.h" +#include "tests/cxx/binary_type_trait-i2.h" + +tests/cxx/binary_type_trait.cc should remove these lines: +- #include "tests/cxx/binary_type_trait-d1.h" // lines XX-XX + +The full include-list for tests/cxx/binary_type_trait.cc: +#include "tests/cxx/binary_type_trait-i1.h" // for BinaryTypeTraitBase +#include "tests/cxx/binary_type_trait-i2.h" // for BinaryTypeTraitDerived + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/builtins_new_included.cc b/tests/cxx/builtins_new_included.cc deleted file mode 100644 index 76efc7b..0000000 --- a/tests/cxx/builtins_new_included.cc +++ /dev/null @@ -1,31 +0,0 @@ -//===--- builtins_new_included.cc - test input file for iwyu --------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// Test that iwyu suggests the include for be removed if only -// built-in functions are used. - -#include - -void foo() { - char* ch = new char; - delete ch; - int* int_array = new int[10]; - delete[] int_array; -} - -/**** IWYU_SUMMARY - -tests/cxx/builtins_new_included.cc should add these lines: - -tests/cxx/builtins_new_included.cc should remove these lines: -- #include // lines XX-XX - -The full include-list for tests/cxx/builtins_new_included.cc: - -***** IWYU_SUMMARY */ diff --git a/tests/cxx/builtins_template.cc b/tests/cxx/builtins_template.cc index 71ca61c..9f16f3a 100644 --- a/tests/cxx/builtins_template.cc +++ b/tests/cxx/builtins_template.cc @@ -14,6 +14,8 @@ __type_pack_element<0, int> tp; template struct A {}; __make_integer_seq seq; +class Foo {}; +__type_pack_element<0, Foo> foo; /**** IWYU_SUMMARY diff --git a/tests/cxx/dotdot.cc b/tests/cxx/dotdot.cc new file mode 100644 index 0000000..16eca77 --- /dev/null +++ b/tests/cxx/dotdot.cc @@ -0,0 +1,29 @@ +//===--- dotdot.cc - test input file for iwyu -----------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Tests that IWYU path canonicalization helps understand that +// "tests/cxx/subdir/../indirect.h" and "tests/cxx/indirect.h" are the same +// file. +#include "subdir/dotdot_indirect.h" + +// IWYU: IndirectClass is...*indirect.h +IndirectClass x; + +/**** IWYU_SUMMARY + +tests/cxx/dotdot.cc should add these lines: +#include "tests/cxx/indirect.h" + +tests/cxx/dotdot.cc should remove these lines: +- #include "subdir/dotdot_indirect.h" // lines XX-XX + +The full include-list for tests/cxx/dotdot.cc: +#include "tests/cxx/indirect.h" // for IndirectClass + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/elaborated_type_union.h b/tests/cxx/elaborated_type_union.h index 4379832..5fe7aad 100644 --- a/tests/cxx/elaborated_type_union.h +++ b/tests/cxx/elaborated_type_union.h @@ -1,4 +1,4 @@ -//===--- elaborated_type_union.h - test input file for iwyu----------------===// +//===--- elaborated_type_union.h - test input file for iwyu ---------------===// // // The LLVM Compiler Infrastructure // diff --git a/tests/cxx/enum_base-d1.h b/tests/cxx/enum_base-d1.h new file mode 100644 index 0000000..925d921 --- /dev/null +++ b/tests/cxx/enum_base-d1.h @@ -0,0 +1,15 @@ +//===--- enum_base-d1.h - test input file for iwyu ------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_ENUM_BASE_D1_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_ENUM_BASE_D1_H_ + +#include "tests/cxx/enum_base-i1.h" + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_ENUM_BASE_D1_H_ diff --git a/tests/cxx/enum_base-i1.h b/tests/cxx/enum_base-i1.h new file mode 100644 index 0000000..aef08da --- /dev/null +++ b/tests/cxx/enum_base-i1.h @@ -0,0 +1,15 @@ +//===--- enum_base-i1.h - test input file for iwyu ------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_ENUM_BASE_I1_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_ENUM_BASE_I1_H_ + +using int_t = int; + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_ENUM_BASE_I1_H_ diff --git a/tests/cxx/enum_base.cc b/tests/cxx/enum_base.cc new file mode 100644 index 0000000..517f611 --- /dev/null +++ b/tests/cxx/enum_base.cc @@ -0,0 +1,29 @@ +//===--- enum_base.cc - test input file for iwyu --------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "tests/cxx/enum_base-d1.h" + +// IWYU: int_t is...*tests/cxx/enum_base-i1.h +enum class Test : int_t { + VALUE1, + VALUE2 +}; + +/**** IWYU_SUMMARY + +tests/cxx/enum_base.cc should add these lines: +#include "tests/cxx/enum_base-i1.h" + +tests/cxx/enum_base.cc should remove these lines: +- #include "tests/cxx/enum_base-d1.h" // lines XX-XX + +The full include-list for tests/cxx/enum_base.cc: +#include "tests/cxx/enum_base-i1.h" // for int_t + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/explicit_instantiation-template.h b/tests/cxx/explicit_instantiation-template.h index 19d4a5a..c058cb1 100644 --- a/tests/cxx/explicit_instantiation-template.h +++ b/tests/cxx/explicit_instantiation-template.h @@ -1,4 +1,4 @@ -//===---- explicit_instantiation-template.h - test input file for iwyu ----===// +//===--- explicit_instantiation-template.h - test input file for iwyu -----===// // // The LLVM Compiler Infrastructure // diff --git a/tests/cxx/explicit_instantiation-template_direct.h b/tests/cxx/explicit_instantiation-template_direct.h index 9df65f7..dc6a854 100644 --- a/tests/cxx/explicit_instantiation-template_direct.h +++ b/tests/cxx/explicit_instantiation-template_direct.h @@ -1,4 +1,4 @@ -//===- explicit_instantiation-template_direct.h - test input file for iwyu ===// +//===--- explicit_instantiation-template_direct.h - test input ------------===// // // The LLVM Compiler Infrastructure // diff --git a/tests/cxx/explicit_instantiation.cc b/tests/cxx/explicit_instantiation.cc index c3af267..07acdf4 100644 --- a/tests/cxx/explicit_instantiation.cc +++ b/tests/cxx/explicit_instantiation.cc @@ -1,4 +1,4 @@ -//===-------- explicit_instantiation.cc - test input file for iwyu --------===// +//===--- explicit_instantiation.cc - test input file for iwyu -------------===// // // The LLVM Compiler Infrastructure // diff --git a/tests/cxx/explicit_instantiation2-template_helpers.h b/tests/cxx/explicit_instantiation2-template_helpers.h index 71c3679..8de1d98 100644 --- a/tests/cxx/explicit_instantiation2-template_helpers.h +++ b/tests/cxx/explicit_instantiation2-template_helpers.h @@ -1,4 +1,4 @@ -//=== explicit_instantiation2-template_helpers.h - test input file for iwyu ==// +//===--- explicit_instantiation2-template_helpers.h - test input ----------===// // // The LLVM Compiler Infrastructure // diff --git a/tests/cxx/explicit_instantiation2-template_short.h b/tests/cxx/explicit_instantiation2-template_short.h index 5bae3fe..248fde2 100644 --- a/tests/cxx/explicit_instantiation2-template_short.h +++ b/tests/cxx/explicit_instantiation2-template_short.h @@ -1,5 +1,4 @@ - -//===- explicit_instantiation2-template_short.h - test input file for iwyu ===// +//===--- explicit_instantiation2-template_short.h - test input ------------===// // // The LLVM Compiler Infrastructure // @@ -7,6 +6,7 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// + #ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_EXPLICIT_INSTANTIATION2_TEMPLATE_SHORT_H_ #define INCLUDE_WHAT_YOU_USE_TESTS_CXX_EXPLICIT_INSTANTIATION2_TEMPLATE_SHORT_H_ diff --git a/tests/cxx/explicit_instantiation2-template_short_direct.h b/tests/cxx/explicit_instantiation2-template_short_direct.h index 17c9845..0a771f2 100644 --- a/tests/cxx/explicit_instantiation2-template_short_direct.h +++ b/tests/cxx/explicit_instantiation2-template_short_direct.h @@ -1,4 +1,4 @@ -// explicit_instantiation2-template_short_direct.h - test input file for iwyu // +//===--- explicit_instantiation2-template_short_direct.h - test input -----===// // // The LLVM Compiler Infrastructure // @@ -6,6 +6,7 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// + #ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_EXPLICIT_INSTANTIATION2_TEMPLATE_SHORT_DIRECT_H_ #define INCLUDE_WHAT_YOU_USE_TESTS_CXX_EXPLICIT_INSTANTIATION2_TEMPLATE_SHORT_DIRECT_H_ diff --git a/tests/cxx/explicit_instantiation2.cc b/tests/cxx/explicit_instantiation2.cc index 168d6c8..2c2fd88 100644 --- a/tests/cxx/explicit_instantiation2.cc +++ b/tests/cxx/explicit_instantiation2.cc @@ -1,4 +1,4 @@ -//===------- explicit_instantiation2.cc - test input file for iwyu --------===// +//===--- explicit_instantiation2.cc - test input file for iwyu ------------===// // // The LLVM Compiler Infrastructure // diff --git a/tests/cxx/export_near.h b/tests/cxx/export_near.h new file mode 100644 index 0000000..15fef16 --- /dev/null +++ b/tests/cxx/export_near.h @@ -0,0 +1,20 @@ +//===--- export_near.h - test input file for iwyu -------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// This file is meant to be a generic exporting header. Similarly to +// direct_near.h, it includes indirect.h. However, unlike that file, this one +// exports indirect.h, and therefore is a valid file to include to access +// IndirectClass. + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_EXPORT_NEAR_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_EXPORT_NEAR_H_ + +#include "indirect.h" // IWYU pragma: export + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_EXPORT_NEAR_H_ diff --git a/tests/cxx/export_private_near.h b/tests/cxx/export_private_near.h new file mode 100644 index 0000000..eab0c8b --- /dev/null +++ b/tests/cxx/export_private_near.h @@ -0,0 +1,20 @@ +//===--- export_private_near.h - test input file for iwyu -----------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// This file is meant to be a generic exporting header. Similarly to +// export_near.h, it exports another header. However, unlike that file, this +// one exports private.h, which is marked private, and therefore IWYU should +// not allow you to directly include private.h. + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_EXPORT_PRIVATE_NEAR_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_EXPORT_PRIVATE_NEAR_H_ + +#include "private.h" // IWYU pragma: export + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_EXPORT_PRIVATE_NEAR_H_ diff --git a/tests/cxx/fwd_decl_final-d1.h b/tests/cxx/fwd_decl_final-d1.h new file mode 100644 index 0000000..c3f3a28 --- /dev/null +++ b/tests/cxx/fwd_decl_final-d1.h @@ -0,0 +1,19 @@ +//===--- fwd_decl_final-d1.h - test input file for iwyu -------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_FWD_DECL_FINAL_D1_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_FWD_DECL_FINAL_D1_H_ + + +template +class FinalTemplate final {}; + +class FinalClass final {}; + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_FWD_DECL_FINAL_D1_H_ diff --git a/tests/cxx/fwd_decl_final.cc b/tests/cxx/fwd_decl_final.cc new file mode 100644 index 0000000..c40bdf5 --- /dev/null +++ b/tests/cxx/fwd_decl_final.cc @@ -0,0 +1,31 @@ +//===--- fwd_decl_final.cc - test input file for iwyu ---------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "tests/cxx/fwd_decl_final.h" + +void FwdDeclFinal::testFinalTemplate(FinalTemplate* finalTemplate) { +} + +void FwdDeclFinal::testFinalClass(FinalClass* finalClass) { +} + +/**** IWYU_SUMMARY + +tests/cxx/fwd_decl_final.cc should add these lines: +class FinalClass; +template class FinalTemplate; + +tests/cxx/fwd_decl_final.cc should remove these lines: + +The full include-list for tests/cxx/fwd_decl_final.cc: +#include "tests/cxx/fwd_decl_final.h" +class FinalClass; +template class FinalTemplate; + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/fwd_decl_final.h b/tests/cxx/fwd_decl_final.h new file mode 100644 index 0000000..103bcd5 --- /dev/null +++ b/tests/cxx/fwd_decl_final.h @@ -0,0 +1,36 @@ +//===--- fwd_decl_final.h - test input file for iwyu ----------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_FWD_DECL_FINAL_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_FWD_DECL_FINAL_H_ + +#include "tests/cxx/fwd_decl_final-d1.h" + +class FwdDeclFinal { +public: + void testFinalTemplate(FinalTemplate* finalTemplate); + void testFinalClass(FinalClass* finalClass); +}; + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_FWD_DECL_FINAL_H_ + +/**** IWYU_SUMMARY + +tests/cxx/fwd_decl_final.h should add these lines: +class FinalClass; +template class FinalTemplate; + +tests/cxx/fwd_decl_final.h should remove these lines: +- #include "tests/cxx/fwd_decl_final-d1.h" // lines XX-XX + +The full include-list for tests/cxx/fwd_decl_final.h: +class FinalClass; +template class FinalTemplate; + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/fwd_decl_of_nested_class_defined_later.cc b/tests/cxx/fwd_decl_of_nested_class_defined_later.cc index dadf140..cbe83cb 100644 --- a/tests/cxx/fwd_decl_of_nested_class_defined_later.cc +++ b/tests/cxx/fwd_decl_of_nested_class_defined_later.cc @@ -1,4 +1,4 @@ -//===--- fwd_decl_of_nested_class_defined_later.cc - test input file for iwyu ---===// +//===--- fwd_decl_of_nested_class_defined_later.cc - test input file ------===// // // The LLVM Compiler Infrastructure // diff --git a/tests/cxx/header_in_subdir.cc b/tests/cxx/header_in_subdir.cc new file mode 100644 index 0000000..cb4a75a --- /dev/null +++ b/tests/cxx/header_in_subdir.cc @@ -0,0 +1,30 @@ +//===--- header_in_subdir.cc - test input file for iwyu -------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Test that subdirs are correctly recognized + +#include "subdir/direct_subdir.h" + +void foo() { + // IWYU: IndirectSubDirClass is...*indirect_subdir.h + IndirectSubDirClass ic; +} + +/**** IWYU_SUMMARY + +tests/cxx/header_in_subdir.cc should add these lines: +#include "tests/cxx/subdir/indirect_subdir.h" + +tests/cxx/header_in_subdir.cc should remove these lines: +- #include "subdir/direct_subdir.h" // lines XX-XX + +The full include-list for tests/cxx/header_in_subdir.cc: +#include "tests/cxx/subdir/indirect_subdir.h" // for IndirectSubDirClass + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/header_in_subdir_nopath.cc b/tests/cxx/header_in_subdir_nopath.cc new file mode 100644 index 0000000..57a0cac --- /dev/null +++ b/tests/cxx/header_in_subdir_nopath.cc @@ -0,0 +1,30 @@ +//===--- header_in_subdir_nopath.cc - test input file for iwyu ------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Test that subdirs are correctly recognized. Use without "-I ." + +#include "subdir/direct_subdir.h" + +void foo() { + // IWYU: IndirectSubDirClass is...*indirect_subdir.h + IndirectSubDirClass ic; +} + +/**** IWYU_SUMMARY + +tests/cxx/header_in_subdir_nopath.cc should add these lines: +#include "subdir/indirect_subdir.h" + +tests/cxx/header_in_subdir_nopath.cc should remove these lines: +- #include "subdir/direct_subdir.h" // lines XX-XX + +The full include-list for tests/cxx/header_in_subdir_nopath.cc: +#include "subdir/indirect_subdir.h" // for IndirectSubDirClass + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/header_in_subfolder.cc b/tests/cxx/header_in_subfolder.cc deleted file mode 100644 index 0734ca4..0000000 --- a/tests/cxx/header_in_subfolder.cc +++ /dev/null @@ -1,30 +0,0 @@ -//===--- header_in_subfolder.cc - test input file for iwyu ----------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// Test that subfolders are correctly recognized - -#include "subfolder/direct_subfolder.h" - -void foo() { - // IWYU: IndirectSubfolderClass is...*indirect_subfolder.h - IndirectSubfolderClass ic; -} - -/**** IWYU_SUMMARY - -tests/cxx/header_in_subfolder.cc should add these lines: -#include "tests/cxx/subfolder/indirect_subfolder.h" - -tests/cxx/header_in_subfolder.cc should remove these lines: -- #include "subfolder/direct_subfolder.h" // lines XX-XX - -The full include-list for tests/cxx/header_in_subfolder.cc: -#include "tests/cxx/subfolder/indirect_subfolder.h" // for IndirectSubfolderClass - -***** IWYU_SUMMARY */ diff --git a/tests/cxx/header_in_subfolder_nopath.cc b/tests/cxx/header_in_subfolder_nopath.cc deleted file mode 100644 index 43525be..0000000 --- a/tests/cxx/header_in_subfolder_nopath.cc +++ /dev/null @@ -1,30 +0,0 @@ -//===--- header_in_subfolder_nopath.cc - test input file for iwyu ---------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// Test that subfolders are correctly recognized. Use without "-I ." - -#include "subfolder/direct_subfolder.h" - -void foo() { - // IWYU: IndirectSubfolderClass is...*indirect_subfolder.h - IndirectSubfolderClass ic; -} - -/**** IWYU_SUMMARY - -tests/cxx/header_in_subfolder_nopath.cc should add these lines: -#include "subfolder/indirect_subfolder.h" - -tests/cxx/header_in_subfolder_nopath.cc should remove these lines: -- #include "subfolder/direct_subfolder.h" // lines XX-XX - -The full include-list for tests/cxx/header_in_subfolder_nopath.cc: -#include "subfolder/indirect_subfolder.h" // for IndirectSubfolderClass - -***** IWYU_SUMMARY */ diff --git a/tests/cxx/header_near.cc b/tests/cxx/header_near.cc index 3085ff3..010a6d5 100644 --- a/tests/cxx/header_near.cc +++ b/tests/cxx/header_near.cc @@ -1,6 +1,6 @@ //===--- header_near.cc - test input file for iwyu ------------------------===// // -// The LLVM Compiler Infrastructure +// The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. diff --git a/tests/cxx/header_near.h b/tests/cxx/header_near.h index 8ad99a3..1c184f4 100644 --- a/tests/cxx/header_near.h +++ b/tests/cxx/header_near.h @@ -1,6 +1,6 @@ //===--- header_near.h - test input file for iwyu -------------------------===// // -// The LLVM Compiler Infrastructure +// The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. diff --git a/tests/cxx/inline_namespace-d1.h b/tests/cxx/inline_namespace-d1.h new file mode 100644 index 0000000..ca59836 --- /dev/null +++ b/tests/cxx/inline_namespace-d1.h @@ -0,0 +1,15 @@ +//===--- inline_namespace-d1.h - test input file for iwyu -----------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_INLINE_NAMESPACE_D1_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_INLINE_NAMESPACE_D1_H_ + +#include "tests/cxx/inline_namespace-i1.h" + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_INLINE_NAMESPACE_D1_H_ diff --git a/tests/cxx/inline_namespace-i1.h b/tests/cxx/inline_namespace-i1.h new file mode 100644 index 0000000..d7c09dc --- /dev/null +++ b/tests/cxx/inline_namespace-i1.h @@ -0,0 +1,24 @@ +//===--- inline_namespace-i1.h - test input file for iwyu -----------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_INLINE_NAMESPACE_I1_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_INLINE_NAMESPACE_I1_H_ + +namespace xyz { +inline namespace v1 { + +struct Foo { + int value; +}; + +} // namespace v1 +} // namespace xyz + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_INLINE_NAMESPACE_I1_H_ + diff --git a/tests/cxx/inline_namespace.cc b/tests/cxx/inline_namespace.cc new file mode 100644 index 0000000..ae41f89 --- /dev/null +++ b/tests/cxx/inline_namespace.cc @@ -0,0 +1,26 @@ +//===--- inline_namespace.cc - test input file for iwyu -------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Tests that IWYU never considers a decl inside an inline namespace +// forward-declarable, and that diagnostics never mention the inline namespace +// name (xyz::v1). + +#include "tests/cxx/inline_namespace.h" + +// IWYU: xyz::Foo is...*inline_namespace-i1.h +int Function(const xyz::Foo& foo) { + // IWYU: xyz::Foo is...*inline_namespace-i1.h + return foo.value; +} + +/**** IWYU_SUMMARY + +(tests/cxx/inline_namespace.cc has correct #includes/fwd-decls) + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/inline_namespace.h b/tests/cxx/inline_namespace.h new file mode 100644 index 0000000..62f6473 --- /dev/null +++ b/tests/cxx/inline_namespace.h @@ -0,0 +1,35 @@ +//===--- inline_namespace.h - test input file for iwyu --------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_INLINE_NAMESPACE_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_INLINE_NAMESPACE_H_ + +#include "tests/cxx/inline_namespace-d1.h" + +// A forward-declare would typically be enough here, but the presence of the +// inline namespace xyz::v1 disqualifies forward declaration, and promotes it to +// a full use. + +// IWYU: xyz::Foo is...*inline_namespace-i1.h +int Function(const xyz::Foo& foo); + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_INLINE_NAMESPACE_H_ + +/**** IWYU_SUMMARY + +tests/cxx/inline_namespace.h should add these lines: +#include "tests/cxx/inline_namespace-i1.h" + +tests/cxx/inline_namespace.h should remove these lines: +- #include "tests/cxx/inline_namespace-d1.h" // lines XX-XX + +The full include-list for tests/cxx/inline_namespace.h: +#include "tests/cxx/inline_namespace-i1.h" // for Foo + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/keep_moc-d1.h b/tests/cxx/keep_moc-d1.h new file mode 100644 index 0000000..845ba89 --- /dev/null +++ b/tests/cxx/keep_moc-d1.h @@ -0,0 +1,10 @@ +//===--- keep_moc-d1.h - test input file for iwyu -------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "tests/cxx/keep_moc-i1.h" diff --git a/tests/cxx/keep_moc-i1.h b/tests/cxx/keep_moc-i1.h new file mode 100644 index 0000000..b085341 --- /dev/null +++ b/tests/cxx/keep_moc-i1.h @@ -0,0 +1,33 @@ +//===--- keep_moc-i1.h - test input file for iwyu -------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Fake some Qt-isms to be able to declare a QObject-like class below. +#define Q_OBJECT +#define signals public +class QObject {}; + +// Make sure we don't remove .moc even if, as in this case, it's empty. +#include "tests/cxx/keep_moc.moc" + +class QObjectLike : public QObject { + Q_OBJECT + +signals: + void Hello(); +}; + +#undef Q_OBJECT +#undef signals + +/**** IWYU_SUMMARY + +(tests/cxx/keep_moc-i1.h has correct #includes/fwd-decls) + +***** IWYU_SUMMARY */ + diff --git a/tests/cxx/keep_moc.cc b/tests/cxx/keep_moc.cc new file mode 100644 index 0000000..1b229af --- /dev/null +++ b/tests/cxx/keep_moc.cc @@ -0,0 +1,37 @@ +//===--- keep_moc.cc - test input file for iwyu ---------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Tests that IWYU never suggests to remove an include of a Qt .moc file. +// These files are handled by a separate Qt preprocessor (called 'moc'), and +// can't be analyzed in the normal C or C++ sense, The moc preprocessor does +// rudimentary IWYU analysis in its own universe. + +// Out-of-the-blue include of a .moc, to make sure we never remove them. +#include "tests/cxx/keep_moc.moc" +#include "tests/cxx/keep_moc-d1.h" + +void foo() { + // IWYU: QObjectLike is...*keep_moc-i1.h + QObjectLike x; +} + +/**** IWYU_SUMMARY + +tests/cxx/keep_moc.cc should add these lines: +#include "tests/cxx/keep_moc-i1.h" + +tests/cxx/keep_moc.cc should remove these lines: +- #include "tests/cxx/keep_moc-d1.h" // lines XX-XX + +The full include-list for tests/cxx/keep_moc.cc: +#include "tests/cxx/keep_moc-i1.h" // for QObjectLike +#include "tests/cxx/keep_moc.moc" + +***** IWYU_SUMMARY */ + diff --git a/tests/cxx/keep_moc.moc b/tests/cxx/keep_moc.moc new file mode 100644 index 0000000..15526d4 --- /dev/null +++ b/tests/cxx/keep_moc.moc @@ -0,0 +1,13 @@ +//===--- keep_moc.moc - test input file for iwyu --------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// This file intentionally left blank. + +// We use this "mock" .moc to make sure IWYU never suggests removing includes of +// .moc files. diff --git a/tests/cxx/macro_location-byteswap.h b/tests/cxx/macro_location-byteswap.h index 921cf28..7bbd2da 100644 --- a/tests/cxx/macro_location-byteswap.h +++ b/tests/cxx/macro_location-byteswap.h @@ -1,2 +1,11 @@ +//===--- macro_location-byteswap.h - test input file for iwyu -------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + #define bswap(x) ({ int __x = (x); bswap2(__x); }) #define bswap2(x) (x) diff --git a/tests/cxx/no_fwd_decls.cc b/tests/cxx/no_fwd_decls.cc index b1a6eb2..e85eea6 100644 --- a/tests/cxx/no_fwd_decls.cc +++ b/tests/cxx/no_fwd_decls.cc @@ -29,6 +29,10 @@ IndirectClass* global; class LocalFwd; void ForwardDeclareUse(const LocalFwd*); +// IWYU must not remove the forward declaration of this class even though its +// definition can be found in the same file but after the use +class LocalFwd {}; + // A forward-declare that also exists in an included header can be removed. // Normally IWYU would optimize for fewer includes, but in --no_fwd_decls mode // we optimize for fewer redeclarations instead. diff --git a/tests/cxx/operator_new.cc b/tests/cxx/operator_new.cc new file mode 100644 index 0000000..0019bf3 --- /dev/null +++ b/tests/cxx/operator_new.cc @@ -0,0 +1,86 @@ +//===--- operator_new.cc - test input file for iwyu -----------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Test that iwyu suggests the include for be removed if only +// built-in functions are used. + +#include +#include "tests/cxx/direct.h" + +// The most primitive ::operator new/delete are builtins, and are basically +// wrappers around malloc. +void ExplicitOperators() { + // IWYU: IndirectClass needs a declaration + // IWYU: IndirectClass is...*indirect.h + IndirectClass* elem = (IndirectClass*)::operator new(sizeof(IndirectClass)); + ::operator delete(elem); + + // IWYU: IndirectClass needs a declaration + IndirectClass* arr = + // IWYU: IndirectClass needs a declaration + // IWYU: IndirectClass is...*indirect.h + (IndirectClass*)::operator new[](4 * sizeof(IndirectClass)); + ::operator delete[](arr); +} + +// New- and delete-expressions, unless using placement syntax, only use builtin +// operators. They're equivalent with the above, but also run ctors/dtors. +// For placement syntax, see tests/cxx/placement_new.cc +void ExpressionsBuiltinTypes() { + char* elem = new char; + delete elem; + + int* arr = new int[4]; + delete[] arr; +} + +// New- and delete-expressions with user-defined types. +void ExpressionsUserTypes() { + // IWYU: IndirectClass needs a declaration + // IWYU: IndirectClass is...*indirect.h + IndirectClass* elem = new IndirectClass; + // IWYU: IndirectClass is...*indirect.h + delete elem; + + // IWYU: IndirectClass needs a declaration + // IWYU: IndirectClass is...*indirect.h + IndirectClass* arr = new IndirectClass[4]; + // IWYU: IndirectClass is...*indirect.h + delete[] arr; +} + +// Aligned allocation uses operator new(size_t, std::align_val_t) under the +// hood in C++17, but does not require to be included for it. Pre-C++17, +// the alignment is silently ignored (or unsupported if the standard library +// does not support aligned allocation). +void ImplicitAlignedAllocation() { + struct alignas(32) Aligned { + float value[8]; + }; + + Aligned* elem = new Aligned; + delete elem; + + Aligned* arr = new Aligned[10]; + delete[] arr; +} + +/**** IWYU_SUMMARY + +tests/cxx/operator_new.cc should add these lines: +#include "tests/cxx/indirect.h" + +tests/cxx/operator_new.cc should remove these lines: +- #include // lines XX-XX +- #include "tests/cxx/direct.h" // lines XX-XX + +The full include-list for tests/cxx/operator_new.cc: +#include "tests/cxx/indirect.h" // for IndirectClass + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/pch_in_code.cc b/tests/cxx/pch_in_code.cc index bb03922..564c4da 100644 --- a/tests/cxx/pch_in_code.cc +++ b/tests/cxx/pch_in_code.cc @@ -1,4 +1,4 @@ -//===--- pch_inc_code.cc - test input file for iwyu -----------------------===// +//===--- pch_in_code.cc - test input file for iwyu ------------------------===// // // The LLVM Compiler Infrastructure // diff --git a/tests/cxx/placement_new-d1.h b/tests/cxx/placement_new-d1.h new file mode 100644 index 0000000..03e4d54 --- /dev/null +++ b/tests/cxx/placement_new-d1.h @@ -0,0 +1,15 @@ +//===--- placement_new-d1.h - test input file for iwyu ---*- C++ -*--------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_PLACEMENT_NEW_D1_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_PLACEMENT_NEW_D1_H_ + +#include "tests/cxx/placement_new-i1.h" + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_PLACEMENT_NEW_D1_H_ diff --git a/tests/cxx/placement_new-i1.h b/tests/cxx/placement_new-i1.h new file mode 100644 index 0000000..3f5e4fb --- /dev/null +++ b/tests/cxx/placement_new-i1.h @@ -0,0 +1,24 @@ +//===--- placement_new-i1.h - test input file for iwyu ----*- C++ -*-------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_PLACEMENT_NEW_I1_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_PLACEMENT_NEW_I1_H_ + +#include + +template +class ClassTemplate { + public: + ClassTemplate() = default; + + T first; + U second; +}; + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_PLACEMENT_NEW_I1_H_ diff --git a/tests/cxx/placement_new.cc b/tests/cxx/placement_new.cc new file mode 100644 index 0000000..a879a4a --- /dev/null +++ b/tests/cxx/placement_new.cc @@ -0,0 +1,151 @@ +//===--- placement_new.cc - test input file for iwyu ----------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Test that use of placement-new requires include of in all the usual +// scenarios. +// +// Requires -std=c++17 on the command-line to have std::aligned_val_t available +// in . + +#include "tests/cxx/direct.h" +#include "tests/cxx/placement_new-d1.h" + +// Placement new of builtin types. +void PlacementNewBuiltinType() { + // Make sure we only report a use of because of placement new, not + // ordinary new-expressions. + int* newed_int = new int; + // IWYU: operator new is...* + new (newed_int) int(4); + + delete newed_int; +} + +// Placement new of user-defined type. +void PlacementNewUserType() { + // IWYU: IndirectClass needs a declaration + // IWYU: IndirectClass is...*indirect.h + IndirectClass* icptr = new IndirectClass; + + // IWYU: IndirectClass is...*indirect.h + // IWYU: operator new is...* + new (icptr) IndirectClass; + + // IWYU: IndirectClass is...*indirect.h + delete icptr; +} + +// Placement new in macro, use is attributed to the macro. +static char global_buffer[256]; +// IWYU: operator new is...* +#define CONSTRUCT_GLOBAL(T) new (global_buffer) T; + +void PlacementNewInMacro() { + // IWYU: IndirectClass needs a declaration + // IWYU: IndirectClass is...*indirect.h + IndirectClass* a = CONSTRUCT_GLOBAL(IndirectClass); +} + +// Placement new inside a template. +template +void PlacementNewInTemplate(T t) { + static char buffer[sizeof(t)]; + // These should all be iwyu violations here, even though we can't be + // *sure* some of these are actually placement new until we get a + // specific type for T (at template-instantiation time). + // IWYU: operator new is...* + new (&t) int; + // IWYU: operator new is...* + new (buffer) T(); + // IWYU: operator new is...* + new (&t) T(); +} + +// Placement new when the newed type _is_ a template. +void PlacementNewOfTemplate() { + // IWYU: IndirectClass needs a declaration + // IWYU: IndirectClass is...*indirect.h + // IWYU: ClassTemplate is...*placement_new-i1.h + char template_storage[sizeof(ClassTemplate)]; + + // IWYU: IndirectClass needs a declaration + // IWYU: ClassTemplate needs a declaration + ClassTemplate* placement_newed_template = + // Need because of placement new, and requires both template and + // arguments as complete types. + // + // IWYU: IndirectClass needs a declaration + // IWYU: IndirectClass is...*indirect.h + // IWYU: ClassTemplate is...*placement_new-i1.h + // IWYU: operator new is...* + new (template_storage) ClassTemplate(); + + // Make sure we handle it right when we explicitly call the dtor, as well. + // IWYU: ClassTemplate is...*placement_new-i1.h + placement_newed_template->~ClassTemplate(); +} + +// new(std::nothrow) is not strictly placement allocation, but it uses placement +// syntax to adjust exception policy. +// To use 'std::nothrow' we must include , even if we don't need it for +// 'new' itself. +void NoThrow() { + // IWYU: IndirectClass needs a declaration + // IWYU: IndirectClass is...*indirect.h + // IWYU: std::nothrow is...* + IndirectClass* elem = new (std::nothrow) IndirectClass; + // IWYU: IndirectClass is...*indirect.h + delete elem; + + // IWYU: IndirectClass needs a declaration + // IWYU: IndirectClass is...*indirect.h + // IWYU: std::nothrow is...* + IndirectClass* arr = new (std::nothrow) IndirectClass[4]; + // IWYU: IndirectClass is...*indirect.h + delete[] arr; +} + +// new(std::align_val_t) is not strictly placement allocation, but it uses +// placement syntax to provide alignment hints. +// To use 'std::align_val_t' we must include , even if we don't need it +// for 'new' itself. +// The aligned allocation mechanics are only available as of C++17. +void ExplicitAlignedAllocation() { + // IWYU: IndirectClass needs a declaration + // IWYU: IndirectClass is...*indirect.h + // IWYU: std::align_val_t is...* + IndirectClass* elem = new (std::align_val_t(32)) IndirectClass; + // IWYU: IndirectClass is...*indirect.h + delete elem; + + // IWYU: IndirectClass needs a declaration + // IWYU: IndirectClass is...*indirect.h + // IWYU: std::align_val_t is...* + IndirectClass* arr = new (std::align_val_t(32)) IndirectClass[10]; + // IWYU: IndirectClass is...*indirect.h + delete[] arr; +} + +/**** IWYU_SUMMARY + +tests/cxx/placement_new.cc should add these lines: +#include +#include "tests/cxx/indirect.h" +#include "tests/cxx/placement_new-i1.h" + +tests/cxx/placement_new.cc should remove these lines: +- #include "tests/cxx/direct.h" // lines XX-XX +- #include "tests/cxx/placement_new-d1.h" // lines XX-XX + +The full include-list for tests/cxx/placement_new.cc: +#include // for align_val_t, nothrow, operator new +#include "tests/cxx/indirect.h" // for IndirectClass +#include "tests/cxx/placement_new-i1.h" // for ClassTemplate + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/precomputed_tpl_args.cc b/tests/cxx/precomputed_tpl_args.cc index a98a09e..cfb9e0a 100644 --- a/tests/cxx/precomputed_tpl_args.cc +++ b/tests/cxx/precomputed_tpl_args.cc @@ -61,11 +61,10 @@ std::bitset<5> bitset; // for map, we should only consider T. template class TemplatedClass { - // TODO(csilvers): IWYU: SpecializationClass is...*precomputed_tpl_args-i1.h - // TODO(csilvers): IWYU: std::less is...*precomputed_tpl_args-i1.h + // IWYU: SpecializationClass is...*precomputed_tpl_args-i1.h // IWYU: SpecializationClass needs a declaration std::map t1; - // TODO(csilvers): IWYU: IndirectClass is...*precomputed_tpl_args-i1.h + // IWYU: IndirectClass is...*precomputed_tpl_args-i1.h // IWYU: IndirectClass needs a declaration std::map t3; }; diff --git a/tests/cxx/private.h b/tests/cxx/private.h new file mode 100644 index 0000000..802d42d --- /dev/null +++ b/tests/cxx/private.h @@ -0,0 +1,22 @@ +//===--- private.h - test input file for iwyu -----------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// This file is meant to be #included by "export_private_near.h". The pragmas +// in these two headers mean that export_private.h is the normal header to +// include to access PrivateClass, rather than including this file directly. + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_PRIVATE_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_PRIVATE_H_ + +// IWYU pragma: private + +class PrivateClass { +}; + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_PRIVATE_H_ diff --git a/tests/cxx/quoted_includes_first.cc b/tests/cxx/quoted_includes_first.cc index dbdee4e..893fba1 100644 --- a/tests/cxx/quoted_includes_first.cc +++ b/tests/cxx/quoted_includes_first.cc @@ -14,11 +14,11 @@ #include #include #include -#include "subfolder/indirect_subfolder.h" +#include "subdir/indirect_subdir.h" #include "quoted_includes_first.h" -std::unique_ptr CreateIndirectSubfolderClass() { - return std::unique_ptr(new IndirectSubfolderClass); +std::unique_ptr CreateIndirectSubDirClass() { + return std::unique_ptr(new IndirectSubDirClass); } /**** IWYU_SUMMARY @@ -33,7 +33,7 @@ tests/cxx/quoted_includes_first.cc should remove these lines: The full include-list for tests/cxx/quoted_includes_first.cc: #include "tests/cxx/pch.h" #include "quoted_includes_first.h" -#include "subfolder/indirect_subfolder.h" // for IndirectSubfolderClass +#include "subdir/indirect_subdir.h" // for IndirectSubDirClass #include // for unique_ptr ***** IWYU_SUMMARY */ diff --git a/tests/cxx/quoted_includes_first.h b/tests/cxx/quoted_includes_first.h index 9016c5d..2b5cac0 100644 --- a/tests/cxx/quoted_includes_first.h +++ b/tests/cxx/quoted_includes_first.h @@ -11,23 +11,23 @@ #include #include #include -#include "subfolder/indirect_subfolder.h" +#include "subdir/indirect_subdir.h" -std::unique_ptr CreateIndirectSubfolderClass(); +std::unique_ptr CreateIndirectSubDirClass(); /**** IWYU_SUMMARY tests/cxx/quoted_includes_first.h should add these lines: -class IndirectSubfolderClass; +class IndirectSubDirClass; tests/cxx/quoted_includes_first.h should remove these lines: -- #include "subfolder/indirect_subfolder.h" // lines XX-XX +- #include "subdir/indirect_subdir.h" // lines XX-XX - #include // lines XX-XX - #include // lines XX-XX - #include // lines XX-XX The full include-list for tests/cxx/quoted_includes_first.h: #include // for unique_ptr -class IndirectSubfolderClass; +class IndirectSubDirClass; ***** IWYU_SUMMARY */ diff --git a/tests/cxx/relative_exported_mapped_include-d1.h b/tests/cxx/relative_exported_mapped_include-d1.h new file mode 100644 index 0000000..2ec3d97 --- /dev/null +++ b/tests/cxx/relative_exported_mapped_include-d1.h @@ -0,0 +1,15 @@ +//===--- relative_exported_mapped_include-d1.h - test input file for iwyu -===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_RELATIVE_EXPORTED_MAPPED_INCLUDE_D1_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_RELATIVE_EXPORTED_MAPPED_INCLUDE_D1_H_ + +#include // IWYU pragma: export + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_RELATIVE_EXPORTED_MAPPED_INCLUDE_D1_H_ diff --git a/tests/cxx/relative_exported_mapped_include.cc b/tests/cxx/relative_exported_mapped_include.cc new file mode 100644 index 0000000..b11428e --- /dev/null +++ b/tests/cxx/relative_exported_mapped_include.cc @@ -0,0 +1,22 @@ +//===--- relative_exported_mapped_include.cc - test input file for iwyu ---===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Ensure that when an include is added which is the public mapping of a +// symbol, that header can be added as a relative include rather than using a +// full path. + +#include "relative_exported_mapped_include-d1.h" + +MappedToExportedHeader x; + +/**** IWYU_SUMMARY + +(tests/cxx/relative_exported_mapped_include.cc has correct #includes/fwd-decls) + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/relative_exported_mapped_include.imp b/tests/cxx/relative_exported_mapped_include.imp new file mode 100644 index 0000000..cacde17 --- /dev/null +++ b/tests/cxx/relative_exported_mapped_include.imp @@ -0,0 +1,3 @@ +[ + { symbol: ["MappedToExportedHeader", "private", "", "public"] }, +] diff --git a/tests/cxx/relative_include_of_double_export-d1.h b/tests/cxx/relative_include_of_double_export-d1.h new file mode 100644 index 0000000..b73df40 --- /dev/null +++ b/tests/cxx/relative_include_of_double_export-d1.h @@ -0,0 +1,15 @@ +//===--- relative_include_of_double_export-d1.h - test input --------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_RELATIVE_INCLUDE_OF_DOUBLE_EXPORT_D1_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_RELATIVE_INCLUDE_OF_DOUBLE_EXPORT_D1_H_ + +#include "export_private_near.h" // IWYU pragma: export + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_RELATIVE_INCLUDE_OF_DOUBLE_EXPORT_D1_H_ diff --git a/tests/cxx/relative_include_of_double_export.cc b/tests/cxx/relative_include_of_double_export.cc new file mode 100644 index 0000000..6a1abdf --- /dev/null +++ b/tests/cxx/relative_include_of_double_export.cc @@ -0,0 +1,23 @@ +//===--- relative_include_of_double_export.cc - test input file for iwyu --===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// The purpose of this test is to ensure that the following relative include +// (i.e. using "" to include something at a location relative to this file) +// remains a relative include rather than being replaced by a different path. +#include "relative_include_of_double_export-d1.h" + +// This class is defined two layers deep within an export double header +// included via the above. +PrivateClass x; + +/**** IWYU_SUMMARY + +(tests/cxx/relative_include_of_double_export.cc has correct #includes/fwd-decls) + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/relative_include_of_export.cc b/tests/cxx/relative_include_of_export.cc new file mode 100644 index 0000000..07abaf1 --- /dev/null +++ b/tests/cxx/relative_include_of_export.cc @@ -0,0 +1,21 @@ +//===--- relative_include_of_export.cc - test input file for iwyu ---------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// The purpose of this test is to ensure that the following relative include +// (i.e. using "" to include something at a location relative to this file) +// remains a relative include rather than being replaced by a different path. +#include "export_near.h" + +IndirectClass x; + +/**** IWYU_SUMMARY + +(tests/cxx/relative_include_of_export.cc has correct #includes/fwd-decls) + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/relative_include_of_export_added-d1.h b/tests/cxx/relative_include_of_export_added-d1.h new file mode 100644 index 0000000..8093ef5 --- /dev/null +++ b/tests/cxx/relative_include_of_export_added-d1.h @@ -0,0 +1,15 @@ +//===--- relative_include_of_export_added-d1.h - test input file for iwyu -===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_RELATIVE_INCLUDE_OF_EXPORT_ADDED_D1_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_RELATIVE_INCLUDE_OF_EXPORT_ADDED_D1_H_ + +#include "export_private_near.h" + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_RELATIVE_INCLUDE_OF_EXPORT_ADDED_D1_H_ diff --git a/tests/cxx/relative_include_of_export_added.cc b/tests/cxx/relative_include_of_export_added.cc new file mode 100644 index 0000000..8cec51e --- /dev/null +++ b/tests/cxx/relative_include_of_export_added.cc @@ -0,0 +1,29 @@ +//===--- relative_include_of_export_added.cc - test input file for iwyu ---===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// The purpose of this test is to ensure that when an include is added which is +// the public counterpart to a private header, that header can be added as a +// relative include rather than using a full path. +#include "relative_include_of_export_added-d1.h" + +// IWYU: PrivateClass is...*"export_private_near.h" +PrivateClass x; + +/**** IWYU_SUMMARY + +tests/cxx/relative_include_of_export_added.cc should add these lines: +#include "export_private_near.h" + +tests/cxx/relative_include_of_export_added.cc should remove these lines: +- #include "relative_include_of_export_added-d1.h" // lines XX-XX + +The full include-list for tests/cxx/relative_include_of_export_added.cc: +#include "export_private_near.h" // for PrivateClass + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/sizeof_in_template_arg.cc b/tests/cxx/sizeof_in_template_arg.cc new file mode 100644 index 0000000..1f555d8 --- /dev/null +++ b/tests/cxx/sizeof_in_template_arg.cc @@ -0,0 +1,41 @@ +//===--- sizeof_in_template_arg.cc - test input file for iwyu -------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "tests/cxx/direct.h" + +// This verifies that using sizeof(...) means that the argument of sizeof +// doesn't count as being in a forward-declare context. In particular, when +// it's used as a template argument. + +template +struct Storage { + char storage[Size]; +}; + +template +struct Public { + Storage storage; +}; + +// IWYU: IndirectClass is...*indirect.h +// IWYU: IndirectClass needs a declaration +Public p; + +/**** IWYU_SUMMARY + +tests/cxx/sizeof_in_template_arg.cc should add these lines: +#include "tests/cxx/indirect.h" + +tests/cxx/sizeof_in_template_arg.cc should remove these lines: +- #include "tests/cxx/direct.h" // lines XX-XX + +The full include-list for tests/cxx/sizeof_in_template_arg.cc: +#include "tests/cxx/indirect.h" // for IndirectClass + +***** IWYU_SUMMARY */ diff --git a/tests/cxx/specialization_needs_decl-d1.h b/tests/cxx/specialization_needs_decl-d1.h index 2b0151d..9d5eff3 100644 --- a/tests/cxx/specialization_needs_decl-d1.h +++ b/tests/cxx/specialization_needs_decl-d1.h @@ -7,6 +7,8 @@ // //===----------------------------------------------------------------------===// +#include "tests/cxx/specialization_needs_decl-i1.h" + template struct TplStruct { }; template <> struct TplStruct { }; diff --git a/tests/cxx/specialization_needs_decl-i1.h b/tests/cxx/specialization_needs_decl-i1.h new file mode 100644 index 0000000..42e8778 --- /dev/null +++ b/tests/cxx/specialization_needs_decl-i1.h @@ -0,0 +1,18 @@ +//===--- specialization_needs_decl-i1.h - test input file -------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// This is employed to show that when the template specialization is used, the +// base template is not required in full. Issue #735. + +// Base template +template +struct Template; + +// Specialization for int +template<> struct Template { int x; }; diff --git a/tests/cxx/specialization_needs_decl.cc b/tests/cxx/specialization_needs_decl.cc index 91b3e61..750cbdc 100644 --- a/tests/cxx/specialization_needs_decl.cc +++ b/tests/cxx/specialization_needs_decl.cc @@ -19,15 +19,26 @@ template<> struct TplStruct { }; // the definition. template<> struct TplStruct; +// Full-using a specialization requires definition of the specialization to be +// included. Not the base template. + +// IWYU: Template needs a declaration +int f(Template& t) { + // IWYU: Template is...*specialization_needs_decl-i1.h + return t.x; +} + /**** IWYU_SUMMARY tests/cxx/specialization_needs_decl.cc should add these lines: +#include "tests/cxx/specialization_needs_decl-i1.h" template struct TplStruct; tests/cxx/specialization_needs_decl.cc should remove these lines: - #include "tests/cxx/specialization_needs_decl-d1.h" // lines XX-XX The full include-list for tests/cxx/specialization_needs_decl.cc: +#include "tests/cxx/specialization_needs_decl-i1.h" // for Template template struct TplStruct; ***** IWYU_SUMMARY */ diff --git a/tests/cxx/subdir/direct_subdir.h b/tests/cxx/subdir/direct_subdir.h new file mode 100644 index 0000000..3e7847a --- /dev/null +++ b/tests/cxx/subdir/direct_subdir.h @@ -0,0 +1,17 @@ +//===--- direct_subdir.h - test input file for iwyu -----------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// This file includes only another file in the subdir + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_DIRECT_SUBDIR_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_DIRECT_SUBDIR_H_ + +#include "indirect_subdir.h" + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_DIRECT_SUBDIR_H_ diff --git a/tests/cxx/subdir/dotdot_indirect.h b/tests/cxx/subdir/dotdot_indirect.h new file mode 100644 index 0000000..39bb2ef --- /dev/null +++ b/tests/cxx/subdir/dotdot_indirect.h @@ -0,0 +1,18 @@ +//===--- dotdot_indirect.h - test input file for iwyu ---------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Include a file using relative path to help test canonicalization when IWYU +// suggests additions. + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_DOTDOT_INDIRECT_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_DOTDOT_INDIRECT_H_ + +#include "../indirect.h" + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_DOTDOT_INDIRECT_H_ diff --git a/tests/cxx/subdir/indirect_subdir.h b/tests/cxx/subdir/indirect_subdir.h new file mode 100644 index 0000000..d6b0323 --- /dev/null +++ b/tests/cxx/subdir/indirect_subdir.h @@ -0,0 +1,16 @@ +//===--- indirect_subdir.h - test input file for iwyu ---------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_INDIRECT_SUBDIR_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_INDIRECT_SUBDIR_H_ + +class IndirectSubDirClass {}; + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_INDIRECT_SUBDIR_H_ diff --git a/tests/cxx/subdir/relative_exported_mapped_include-i1.h b/tests/cxx/subdir/relative_exported_mapped_include-i1.h new file mode 100644 index 0000000..eb1d3e7 --- /dev/null +++ b/tests/cxx/subdir/relative_exported_mapped_include-i1.h @@ -0,0 +1,15 @@ +//===--- relative_exported_mapped_include-i1.h - test input file ----------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef INCLUDE_WHAT_YOU_USE_TESTS_CXX_RELATIVE_EXPORTED_MAPPED_INCLUDE_I1_H_ +#define INCLUDE_WHAT_YOU_USE_TESTS_CXX_RELATIVE_EXPORTED_MAPPED_INCLUDE_I1_H_ + +enum MappedToExportedHeader {}; + +#endif // INCLUDE_WHAT_YOU_USE_TESTS_CXX_RELATIVE_EXPORTED_MAPPED_INCLUDE_I1_H_ diff --git a/tests/cxx/subfolder/direct_subfolder.h b/tests/cxx/subfolder/direct_subfolder.h deleted file mode 100644 index 9c1d10a..0000000 --- a/tests/cxx/subfolder/direct_subfolder.h +++ /dev/null @@ -1,17 +0,0 @@ -//===--- direct_subfolder.h - test input file for iwyu --------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// This file includes only another file in the subfolder - -#ifndef INCLUDE_WHAT_YOU_USE_TESTS_DIRECT_SUBFOLDER_H_ -#define INCLUDE_WHAT_YOU_USE_TESTS_DIRECT_SUBFOLDER_H_ - -#include "indirect_subfolder.h" - -#endif // INCLUDE_WHAT_YOU_USE_TESTS_DIRECT_SUBFOLDER_H_ diff --git a/tests/cxx/subfolder/indirect_subfolder.h b/tests/cxx/subfolder/indirect_subfolder.h deleted file mode 100644 index 5bf5cd6..0000000 --- a/tests/cxx/subfolder/indirect_subfolder.h +++ /dev/null @@ -1,16 +0,0 @@ -//===--- indirect_subfolder.h - test input file for iwyu ------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - - -#ifndef INCLUDE_WHAT_YOU_USE_TESTS_INDIRECT_SUBFOLDER_H_ -#define INCLUDE_WHAT_YOU_USE_TESTS_INDIRECT_SUBFOLDER_H_ - -class IndirectSubfolderClass {}; - -#endif // INCLUDE_WHAT_YOU_USE_TESTS_INDIRECT_SUBFOLDER_H_ diff --git a/tests/cxx/template_default_args_roundtrip-direct.h b/tests/cxx/template_default_args_roundtrip-direct.h index 9249b78..4159a8e 100644 --- a/tests/cxx/template_default_args_roundtrip-direct.h +++ b/tests/cxx/template_default_args_roundtrip-direct.h @@ -1,4 +1,4 @@ -//=== template_default_args_roundtrip-direct.h - test input file for iwyu -===// +//===--- template_default_args_roundtrip-direct.h - test input ------------===// // // The LLVM Compiler Infrastructure // diff --git a/tests/cxx/template_default_args_roundtrip-indirect.h b/tests/cxx/template_default_args_roundtrip-indirect.h index 8bf594a..1dfcb6f 100644 --- a/tests/cxx/template_default_args_roundtrip-indirect.h +++ b/tests/cxx/template_default_args_roundtrip-indirect.h @@ -1,4 +1,4 @@ -//=== template_default_args_roundtrip-indirect.h - test input file for iwyu ==// +//===--- template_default_args_roundtrip-indirect.h - test input ----------===// // // The LLVM Compiler Infrastructure // diff --git a/tests/cxx/template_default_args_roundtrip-template.h b/tests/cxx/template_default_args_roundtrip-template.h index c190a67..1633a57 100644 --- a/tests/cxx/template_default_args_roundtrip-template.h +++ b/tests/cxx/template_default_args_roundtrip-template.h @@ -1,4 +1,4 @@ -//=== template_default_args_roundtrip-template.h - test input file for iwyu ==// +//===--- template_default_args_roundtrip-template.h - test input ----------===// // // The LLVM Compiler Infrastructure // diff --git a/tests/cxx/template_specialization.cc b/tests/cxx/template_specialization.cc index 0e37fa9..12fa374 100644 --- a/tests/cxx/template_specialization.cc +++ b/tests/cxx/template_specialization.cc @@ -11,6 +11,7 @@ // it to the right location. #include "tests/cxx/template_specialization-d1.h" +#include "tests/cxx/direct.h" template class Foo; @@ -38,18 +39,30 @@ TplTplStruct<> tts; TplTplStruct tts2; +template +struct Specialized; + +template<> +// IWYU: IndirectClass is...*indirect.h +struct Specialized : IndirectClass {}; + + /**** IWYU_SUMMARY tests/cxx/template_specialization.cc should add these lines: +#include "tests/cxx/indirect.h" #include "tests/cxx/template_specialization-i1.h" #include "tests/cxx/template_specialization-i2.h" tests/cxx/template_specialization.cc should remove these lines: +- #include "tests/cxx/direct.h" // lines XX-XX - #include "tests/cxx/template_specialization-d1.h" // lines XX-XX - template class Foo; // lines XX-XX The full include-list for tests/cxx/template_specialization.cc: +#include "tests/cxx/indirect.h" // for IndirectClass #include "tests/cxx/template_specialization-i1.h" // for Foo #include "tests/cxx/template_specialization-i2.h" // for Foo +template struct Specialized; // lines XX-XX+1 ***** IWYU_SUMMARY */ diff --git a/tests/cxx/typedef_in_template.cc b/tests/cxx/typedef_in_template.cc index 48721d7..8e27810 100644 --- a/tests/cxx/typedef_in_template.cc +++ b/tests/cxx/typedef_in_template.cc @@ -7,6 +7,7 @@ // //===----------------------------------------------------------------------===// +#include "tests/cxx/direct.h" #include "tests/cxx/typedef_in_template-d1.h" template @@ -24,34 +25,87 @@ class Container { void Declarations() { - // These do not need the full type for Class because they're template params. + // Just using Container does not need the full type for Class because there + // are only aliases made, which do not require full-uses. - // TODO: This is almost certainly wrong, see bug #431 - // We should not require the full definition of Class for passing it as a - // template argument, but we must require it when the typedef it's aliasing - // is full-used. - // The bug has instructions for how to provoke the error more obviously. + // TODO: But currently this is counted as a full-use because Class is used + // inside a template specialization (of Pair) within the definition of + // Container. + // IWYU: Class is...*typedef_in_template-i1.h + // IWYU: Class needs a declaration + Container c; + + // Full-using any of those aliases *should* require a full use of Class. + // IWYU: Class is...*typedef_in_template-i1.h // IWYU: Class needs a declaration Container::value_type vt; + // IWYU: Class is...*typedef_in_template-i1.h // IWYU: Class needs a declaration Container::pair_type pt; + // IWYU: Class is...*typedef_in_template-i1.h // IWYU: Class needs a declaration Container::alias_type at; } +// STL containers are often implemented via a complex web of type aliases and +// helper classes. Tracking uses through all these layers can be non-trivial. +// The following are some reduced examples in roughly increasing order of +// complexity which can serve as helpful test cases while debugging such +// issues. They were inspired by libstdc++'s implementation of +// std::unordered_map, but don't directly correspond to it. + +// Verify that a full-use of an alias of a template parameter is treated as a +// full-use of that parameter. +template +struct UsesAliasedParameter { + using TAlias = T; + TAlias t; +}; + +// IWYU: IndirectClass is...*indirect.h +// IWYU: IndirectClass needs a declaration +UsesAliasedParameter a; + +// IWYU: IndirectClass is...*indirect.h +// IWYU: IndirectClass needs a declaration +UsesAliasedParameter::TAlias a2; + +// Try a more complex example, through an additional layer of indirection. +template +struct IndirectlyUsesAliasedParameter { + using TAlias = typename UsesAliasedParameter::TAlias; + TAlias t; +}; + +// IWYU: IndirectClass is...*indirect.h +// IWYU: IndirectClass needs a declaration +IndirectlyUsesAliasedParameter b; + +template +struct NestedUseOfAliasedParameter { + using UserAlias = UsesAliasedParameter; + UserAlias a; +}; + +// IWYU: IndirectClass is...*indirect.h +// IWYU: IndirectClass needs a declaration +NestedUseOfAliasedParameter c; /**** IWYU_SUMMARY tests/cxx/typedef_in_template.cc should add these lines: +#include "tests/cxx/indirect.h" #include "tests/cxx/typedef_in_template-i1.h" tests/cxx/typedef_in_template.cc should remove these lines: +- #include "tests/cxx/direct.h" // lines XX-XX - #include "tests/cxx/typedef_in_template-d1.h" // lines XX-XX The full include-list for tests/cxx/typedef_in_template.cc: -#include "tests/cxx/typedef_in_template-i1.h" // for Class (ptr only), Pair +#include "tests/cxx/indirect.h" // for IndirectClass +#include "tests/cxx/typedef_in_template-i1.h" // for Class, Pair ***** IWYU_SUMMARY */ -- cgit v1.2.3 From 23c5b1c69e3ce02b6babd7b40a878e0164ffc5d1 Mon Sep 17 00:00:00 2001 From: Sylvestre Ledru Date: Thu, 26 Nov 2020 15:40:44 +0100 Subject: new upstream release --- debian/changelog | 11 +- debian/patches/GlobalSourceManager.patch | 210 ------------------------------- debian/patches/PrintableStmt.patch | 54 -------- debian/patches/series | 4 - debian/patches/stringref.patch | 146 --------------------- 5 files changed, 6 insertions(+), 419 deletions(-) delete mode 100644 debian/patches/GlobalSourceManager.patch delete mode 100644 debian/patches/PrintableStmt.patch delete mode 100644 debian/patches/stringref.patch diff --git a/debian/changelog b/debian/changelog index 08bfc9c..a93b16d 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,18 +1,19 @@ -iwyu (8.14-1) UNRELEASED; urgency=medium +iwyu (8.15-1) unstable; urgency=medium [ Debian Janitor ] * Set upstream metadata fields: Bug-Database, Bug-Submit, Repository. [ Sylvestre Ledru ] - * New upstream release 0.14 + * New upstream release 0.15 * Move to clang-11 (Closes: #974814) * Add clang-{11,12} in the depends * Upstream updated their versionning on github. it was called - clang_8.0, it is now 0.14; Called this version 8.14 as we cannot - go back to 0.14. Update watch + clang_8.0, it is now 0.15; Called this version 8.15 as we cannot + go back to 0.15. Update watch + - remove stringref.patch, PrintableStmt.patch & GlobalSourceManager.patch * Update watch file format version to 4. - -- Sylvestre Ledru Sun, 15 Nov 2020 10:11:13 +0100 + -- Sylvestre Ledru Thu, 26 Nov 2020 15:40:13 +0100 iwyu (8.0-3) unstable; urgency=medium diff --git a/debian/patches/GlobalSourceManager.patch b/debian/patches/GlobalSourceManager.patch deleted file mode 100644 index 9f40f13..0000000 --- a/debian/patches/GlobalSourceManager.patch +++ /dev/null @@ -1,210 +0,0 @@ -From fbffd6e3be4c409109b06f858368bcee1ea2f99d Mon Sep 17 00:00:00 2001 -From: Kim Grasman -Date: Tue, 22 Sep 2020 19:28:24 +0200 -Subject: [PATCH] Remove source manager from ASTNode constructor - -ASTNode was consistently instantiated using GlobalSourceManager(). The -passed-in source manager was only used in ASTNode::GetLocation(). - -Use GlobalSourceManager() there directly instead to keep the constructor -interface simpler. - -No functional change. ---- - iwyu.cc | 20 ++++++++++---------- - iwyu_ast_util.cc | 9 ++++----- - iwyu_ast_util.h | 42 ++++++++++++++++++------------------------ - 3 files changed, 32 insertions(+), 39 deletions(-) - -diff --git a/iwyu.cc b/iwyu.cc -index 8f934273..931d57b6 100644 ---- a/iwyu.cc -+++ b/iwyu.cc -@@ -322,7 +322,7 @@ class BaseAstVisitor : public RecursiveASTVisitor { - bool TraverseDecl(Decl* decl) { - if (current_ast_node_ && current_ast_node_->StackContainsContent(decl)) - return true; // avoid recursion -- ASTNode node(decl, *GlobalSourceManager()); -+ ASTNode node(decl); - CurrentASTNodeUpdater canu(¤t_ast_node_, &node); - return Base::TraverseDecl(decl); - } -@@ -330,7 +330,7 @@ class BaseAstVisitor : public RecursiveASTVisitor { - bool TraverseStmt(Stmt* stmt) { - if (current_ast_node_ && current_ast_node_->StackContainsContent(stmt)) - return true; // avoid recursion -- ASTNode node(stmt, *GlobalSourceManager()); -+ ASTNode node(stmt); - CurrentASTNodeUpdater canu(¤t_ast_node_, &node); - return Base::TraverseStmt(stmt); - } -@@ -341,7 +341,7 @@ class BaseAstVisitor : public RecursiveASTVisitor { - const Type* type = qualtype.getTypePtr(); - if (current_ast_node_ && current_ast_node_->StackContainsContent(type)) - return true; // avoid recursion -- ASTNode node(type, *GlobalSourceManager()); -+ ASTNode node(type); - CurrentASTNodeUpdater canu(¤t_ast_node_, &node); - return Base::TraverseType(qualtype); - } -@@ -365,7 +365,7 @@ class BaseAstVisitor : public RecursiveASTVisitor { - } - if (current_ast_node_ && current_ast_node_->StackContainsContent(&typeloc)) - return true; // avoid recursion -- ASTNode node(&typeloc, *GlobalSourceManager()); -+ ASTNode node(&typeloc); - CurrentASTNodeUpdater canu(¤t_ast_node_, &node); - return Base::TraverseTypeLoc(typeloc); - } -@@ -373,7 +373,7 @@ class BaseAstVisitor : public RecursiveASTVisitor { - bool TraverseNestedNameSpecifier(NestedNameSpecifier* nns) { - if (nns == nullptr) - return true; -- ASTNode node(nns, *GlobalSourceManager()); -+ ASTNode node(nns); - CurrentASTNodeUpdater canu(¤t_ast_node_, &node); - if (!this->getDerived().VisitNestedNameSpecifier(nns)) - return false; -@@ -383,7 +383,7 @@ class BaseAstVisitor : public RecursiveASTVisitor { - bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc nns_loc) { - if (!nns_loc) // using NNSLoc::operator bool() - return true; -- ASTNode node(&nns_loc, *GlobalSourceManager()); -+ ASTNode node(&nns_loc); - CurrentASTNodeUpdater canu(¤t_ast_node_, &node); - // TODO(csilvers): have VisitNestedNameSpecifierLoc instead. - if (!this->getDerived().VisitNestedNameSpecifier( -@@ -393,7 +393,7 @@ class BaseAstVisitor : public RecursiveASTVisitor { - } - - bool TraverseTemplateName(TemplateName template_name) { -- ASTNode node(&template_name, *GlobalSourceManager()); -+ ASTNode node(&template_name); - CurrentASTNodeUpdater canu(¤t_ast_node_, &node); - if (!this->getDerived().VisitTemplateName(template_name)) - return false; -@@ -401,7 +401,7 @@ class BaseAstVisitor : public RecursiveASTVisitor { - } - - bool TraverseTemplateArgument(const TemplateArgument& arg) { -- ASTNode node(&arg, *GlobalSourceManager()); -+ ASTNode node(&arg); - CurrentASTNodeUpdater canu(¤t_ast_node_, &node); - if (!this->getDerived().VisitTemplateArgument(arg)) - return false; -@@ -409,7 +409,7 @@ class BaseAstVisitor : public RecursiveASTVisitor { - } - - bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc& argloc) { -- ASTNode node(&argloc, *GlobalSourceManager()); -+ ASTNode node(&argloc); - CurrentASTNodeUpdater canu(¤t_ast_node_, &node); - if (!this->getDerived().VisitTemplateArgumentLoc(argloc)) - return false; -@@ -3967,7 +3967,7 @@ class IwyuAstConsumer - if (const TemplateSpecializationType* arg_tmpl = DynCastFrom(arg_type)) { - // Special case: We are instantiating the type in the context of an - // expression. Need to push the type to the AST stack explicitly. -- ASTNode node(arg_tmpl, *GlobalSourceManager()); -+ ASTNode node(arg_tmpl); - node.SetParent(current_ast_node()); - - instantiated_template_visitor_.ScanInstantiatedType( -diff --git a/iwyu_ast_util.cc b/iwyu_ast_util.cc -index b19a11fb..1d37a175 100644 ---- a/iwyu_ast_util.cc -+++ b/iwyu_ast_util.cc -@@ -186,13 +186,12 @@ SourceLocation ASTNode::GetLocation() const { - // locations are in a different file, then we're uncertain of our - // own location. Return an invalid location. - if (retval.isValid()) { -- FullSourceLoc full_loc(retval, source_manager_); -+ clang::SourceManager& sm = *GlobalSourceManager(); -+ FullSourceLoc full_loc(retval, sm); - const FileEntry* spelling_file = -- source_manager_.getFileEntryForID( -- source_manager_.getFileID(full_loc.getSpellingLoc())); -+ sm.getFileEntryForID(sm.getFileID(full_loc.getSpellingLoc())); - const FileEntry* instantiation_file = -- source_manager_.getFileEntryForID( -- source_manager_.getFileID(full_loc.getExpansionLoc())); -+ sm.getFileEntryForID(sm.getFileID(full_loc.getExpansionLoc())); - if (spelling_file != instantiation_file) - return SourceLocation(); - } -diff --git a/iwyu_ast_util.h b/iwyu_ast_util.h -index a66a1d4b..18ddf2d3 100644 ---- a/iwyu_ast_util.h -+++ b/iwyu_ast_util.h -@@ -40,7 +40,6 @@ class ClassTemplateDecl; - class Expr; - class FunctionDecl; - class NamedDecl; --class SourceManager; - class TagDecl; - class TemplateDecl; - class TemplateName; -@@ -72,37 +71,33 @@ class ASTNode { - public: - // In each case, the caller owns the object, and must guarantee it - // lives for at least as long as the ASTNode object does. -- ASTNode(const clang::Decl* decl, const clang::SourceManager& sm) -+ ASTNode(const clang::Decl* decl) - : kind_(kDeclKind), as_decl_(decl), -- parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } -- ASTNode(const clang::Stmt* stmt, const clang::SourceManager& sm) -+ parent_(nullptr), in_fwd_decl_context_(false) { } -+ ASTNode(const clang::Stmt* stmt) - : kind_(kStmtKind), as_stmt_(stmt), -- parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } -- ASTNode(const clang::Type* type, const clang::SourceManager& sm) -+ parent_(nullptr), in_fwd_decl_context_(false) { } -+ ASTNode(const clang::Type* type) - : kind_(kTypeKind), as_type_(type), -- parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } -- ASTNode(const clang::TypeLoc* typeloc, const clang::SourceManager& sm) -+ parent_(nullptr), in_fwd_decl_context_(false) { } -+ ASTNode(const clang::TypeLoc* typeloc) - : kind_(kTypelocKind), as_typeloc_(typeloc), -- parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } -- ASTNode(const clang::NestedNameSpecifier* nns, const clang::SourceManager& sm) -+ parent_(nullptr), in_fwd_decl_context_(false) { } -+ ASTNode(const clang::NestedNameSpecifier* nns) - : kind_(kNNSKind), as_nns_(nns), -- parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } -- ASTNode(const clang::NestedNameSpecifierLoc* nnsloc, -- const clang::SourceManager& sm) -+ parent_(nullptr), in_fwd_decl_context_(false) { } -+ ASTNode(const clang::NestedNameSpecifierLoc* nnsloc) - : kind_(kNNSLocKind), as_nnsloc_(nnsloc), -- parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } -- ASTNode(const clang::TemplateName* template_name, -- const clang::SourceManager& sm) -+ parent_(nullptr), in_fwd_decl_context_(false) { } -+ ASTNode(const clang::TemplateName* template_name) - : kind_(kTemplateNameKind), as_template_name_(template_name), -- parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } -- ASTNode(const clang::TemplateArgument* template_arg, -- const clang::SourceManager& sm) -+ parent_(nullptr), in_fwd_decl_context_(false) { } -+ ASTNode(const clang::TemplateArgument* template_arg) - : kind_(kTemplateArgumentKind), as_template_arg_(template_arg), -- parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } -- ASTNode(const clang::TemplateArgumentLoc* template_argloc, -- const clang::SourceManager& sm) -+ parent_(nullptr), in_fwd_decl_context_(false) { } -+ ASTNode(const clang::TemplateArgumentLoc* template_argloc) - : kind_(kTemplateArgumentLocKind), as_template_argloc_(template_argloc), -- parent_(nullptr), in_fwd_decl_context_(false), source_manager_(sm) { } -+ parent_(nullptr), in_fwd_decl_context_(false) { } - - // A 'forward-declare' context means some parent of us can be - // forward-declared, which means we can be too. e.g. in -@@ -327,7 +322,6 @@ class ASTNode { - }; - const ASTNode* parent_; - bool in_fwd_decl_context_; -- const clang::SourceManager& source_manager_; - }; - - // --- Helper classes for ASTNode. diff --git a/debian/patches/PrintableStmt.patch b/debian/patches/PrintableStmt.patch deleted file mode 100644 index 663a883..0000000 --- a/debian/patches/PrintableStmt.patch +++ /dev/null @@ -1,54 +0,0 @@ -From 30549c6931972456d1e09ff5dbeecd258a8df72b Mon Sep 17 00:00:00 2001 -From: Kim Grasman -Date: Thu, 9 Jul 2020 18:47:56 +0200 -Subject: [PATCH] Implement Stmt printing with ASTDumper - -The Clang API changed in commit 473fbc90d1fbf17e so that Stmt::dump -takes an ASTContext instead of a SourceManager. - -Rather than wire a global ASTContext, reimplement PrintableStmt and -PrintStmt to duplicate the most trivial implementations not requiring -ASTContext. - -No functional change. ---- - iwyu_ast_util.cc | 8 ++++++-- - 1 file changed, 6 insertions(+), 2 deletions(-) - -diff --git a/iwyu_ast_util.cc b/iwyu_ast_util.cc -index d3d4dd1f..b19a11fb 100644 ---- a/iwyu_ast_util.cc -+++ b/iwyu_ast_util.cc -@@ -25,6 +25,7 @@ - #include "llvm/Support/Casting.h" - #include "llvm/Support/raw_ostream.h" - #include "clang/AST/ASTContext.h" -+#include "clang/AST/ASTDumper.h" - #include "clang/AST/CanonicalType.h" - #include "clang/AST/Decl.h" - #include "clang/AST/DeclBase.h" -@@ -46,6 +47,7 @@ namespace clang { - class FileEntry; - } // namespace clang - -+using clang::ASTDumper; - using clang::BlockPointerType; - using clang::CXXConstructExpr; - using clang::CXXConstructorDecl; -@@ -450,12 +452,14 @@ string PrintableDecl(const Decl* decl, bool terse/*=true*/) { - string PrintableStmt(const Stmt* stmt) { - std::string buffer; - raw_string_ostream ostream(buffer); -- stmt->dump(ostream, *GlobalSourceManager()); -+ ASTDumper dumper(ostream, /*ShowColors=*/false); -+ dumper.Visit(stmt); - return ostream.str(); - } - - void PrintStmt(const Stmt* stmt) { -- stmt->dump(*GlobalSourceManager()); // This prints to errs(). -+ ASTDumper dumper(llvm::errs(), /*ShowColors=*/false); -+ dumper.Visit(stmt); - } - - string PrintableType(const Type* type) { diff --git a/debian/patches/series b/debian/patches/series index 06a6a12..151ff26 100644 --- a/debian/patches/series +++ b/debian/patches/series @@ -1,5 +1 @@ -#struct.patch python3.diff -stringref.patch -GlobalSourceManager.patch -PrintableStmt.patch diff --git a/debian/patches/stringref.patch b/debian/patches/stringref.patch deleted file mode 100644 index 171dca2..0000000 --- a/debian/patches/stringref.patch +++ /dev/null @@ -1,146 +0,0 @@ -From 53487d209729d5781007dc0fd6076dc585cb3727 Mon Sep 17 00:00:00 2001 -From: Andrea Bocci -Date: Fri, 28 Feb 2020 17:45:03 +0100 -Subject: [PATCH] Add explicit conversion from llvm::StringRef to std::string - -llvm/llvm-project@777180a makes the llvm::StringRef conversion operator -to std::string explicit. -These changes add a call to the str() method to perform the conversion. - -Signed-off-by: Andrea Bocci ---- - iwyu_driver.cc | 2 +- - iwyu_globals.cc | 4 ++-- - iwyu_lexer_utils.cc | 2 +- - iwyu_location_util.h | 2 +- - iwyu_output.cc | 2 +- - iwyu_path_util.cc | 6 +++--- - iwyu_preprocessor.cc | 4 ++-- - 7 files changed, 11 insertions(+), 11 deletions(-) - -diff --git a/iwyu_driver.cc b/iwyu_driver.cc -index bd163144..42fea35b 100644 ---- a/iwyu_driver.cc -+++ b/iwyu_driver.cc -@@ -79,7 +79,7 @@ std::string GetExecutablePath(const char *Argv0) { - } - - const char *SaveStringInSet(std::set &SavedStrings, StringRef S) { -- return SavedStrings.insert(S).first->c_str(); -+ return SavedStrings.insert(S.str()).first->c_str(); - } - - void ExpandArgsFromBuf(const char *Arg, -diff --git a/iwyu_globals.cc b/iwyu_globals.cc -index 0f58b4dc..26998966 100644 ---- a/iwyu_globals.cc -+++ b/iwyu_globals.cc -@@ -293,7 +293,7 @@ static vector ComputeHeaderSearchPaths( - for (auto it = header_search->system_dir_begin(); - it != header_search->system_dir_end(); ++it) { - if (const DirectoryEntry* entry = it->getDir()) { -- const string path = NormalizeDirPath(MakeAbsolutePath(entry->getName())); -+ const string path = NormalizeDirPath(MakeAbsolutePath(entry->getName().str())); - search_path_map[path] = HeaderSearchPath::kSystemPath; - } - } -@@ -303,7 +303,7 @@ static vector ComputeHeaderSearchPaths( - // search_dir_begin()/end() includes both system and user paths. - // If it's a system path, it's already in the map, so everything - // new is a user path. The insert only 'takes' for new entries. -- const string path = NormalizeDirPath(MakeAbsolutePath(entry->getName())); -+ const string path = NormalizeDirPath(MakeAbsolutePath(entry->getName().str())); - search_path_map.insert(make_pair(path, HeaderSearchPath::kUserPath)); - } - } -diff --git a/iwyu_lexer_utils.cc b/iwyu_lexer_utils.cc -index fcea2d28..648c9da8 100644 ---- a/iwyu_lexer_utils.cc -+++ b/iwyu_lexer_utils.cc -@@ -70,7 +70,7 @@ SourceLocation GetLocationAfter( - string GetIncludeNameAsWritten( - SourceLocation include_loc, - const CharacterDataGetterInterface& data_getter) { -- const string data = GetSourceTextUntilEndOfLine(include_loc, data_getter); -+ const string data = GetSourceTextUntilEndOfLine(include_loc, data_getter).str(); - if (data.empty()) - return data; - string::size_type endpos = string::npos; -diff --git a/iwyu_location_util.h b/iwyu_location_util.h -index 3892a424..6f8cf81c 100644 ---- a/iwyu_location_util.h -+++ b/iwyu_location_util.h -@@ -89,7 +89,7 @@ bool IsInScratchSpace(clang::SourceLocation loc); - - inline string GetFilePath(const clang::FileEntry* file) { - return (IsBuiltinFile(file) ? "" : -- NormalizeFilePath(file->getName())); -+ NormalizeFilePath(file->getName().str())); - } - - //------------------------------------------------------------ -diff --git a/iwyu_output.cc b/iwyu_output.cc -index ca145710..8666c26c 100644 ---- a/iwyu_output.cc -+++ b/iwyu_output.cc -@@ -168,7 +168,7 @@ string GetKindName(const clang::TagDecl* tag_decl) { - if (const FakeNamedDecl* fake = FakeNamedDeclIfItIsOne(named_decl)) { - return fake->kind_name(); - } -- return tag_decl->getKindName(); -+ return tag_decl->getKindName().str(); - } - - string GetQualifiedNameAsString(const clang::NamedDecl* named_decl) { -diff --git a/iwyu_path_util.cc b/iwyu_path_util.cc -index ab4fc800..9987ea47 100644 ---- a/iwyu_path_util.cc -+++ b/iwyu_path_util.cc -@@ -134,7 +134,7 @@ string NormalizeFilePath(const string& path) { - std::replace(normalized.begin(), normalized.end(), '\\', '/'); - #endif - -- return normalized.str(); -+ return normalized.str().str(); - } - - string NormalizeDirPath(const string& path) { -@@ -154,14 +154,14 @@ string MakeAbsolutePath(const string& path) { - std::error_code error = llvm::sys::fs::make_absolute(absolute_path); - CHECK_(!error); - -- return absolute_path.str(); -+ return absolute_path.str().str(); - } - - string MakeAbsolutePath(const string& base_path, const string& relative_path) { - llvm::SmallString<128> absolute_path(base_path); - llvm::sys::path::append(absolute_path, relative_path); - -- return absolute_path.str(); -+ return absolute_path.str().str(); - } - - string GetParentPath(const string& path) { -diff --git a/iwyu_preprocessor.cc b/iwyu_preprocessor.cc -index 58e78595..88b93144 100644 ---- a/iwyu_preprocessor.cc -+++ b/iwyu_preprocessor.cc -@@ -313,7 +313,7 @@ void IwyuPreprocessorInfo::ProcessHeadernameDirectivesInFile( - break; - } - const string filename = GetSourceTextUntilEndOfLine(current_loc, -- DefaultDataGetter()); -+ DefaultDataGetter()).str(); - // Use "" or <> based on where the file lives. - string quoted_private_include; - if (IsSystemIncludeFile(GetFilePath(current_loc))) -@@ -332,7 +332,7 @@ void IwyuPreprocessorInfo::ProcessHeadernameDirectivesInFile( - } - - string after_text = GetSourceTextUntilEndOfLine(current_loc, -- DefaultDataGetter()); -+ DefaultDataGetter()).str(); - const string::size_type close_brace_pos = after_text.find('}'); - if (close_brace_pos == string::npos) { - Warn(current_loc, "@headername directive missing a closing brace"); -- cgit v1.2.3 From 3328924cc33b76ed9650bcd942514f2db8505c9f Mon Sep 17 00:00:00 2001 From: Sylvestre Ledru Date: Thu, 26 Nov 2020 17:33:12 +0100 Subject: fix a typo --- debian/changelog | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/debian/changelog b/debian/changelog index a93b16d..edc4a27 100644 --- a/debian/changelog +++ b/debian/changelog @@ -7,7 +7,7 @@ iwyu (8.15-1) unstable; urgency=medium * New upstream release 0.15 * Move to clang-11 (Closes: #974814) * Add clang-{11,12} in the depends - * Upstream updated their versionning on github. it was called + * Upstream updated their versioning on github. it was called clang_8.0, it is now 0.15; Called this version 8.15 as we cannot go back to 0.15. Update watch - remove stringref.patch, PrintableStmt.patch & GlobalSourceManager.patch -- cgit v1.2.3