Compiler warnings.

This commit is contained in:
Roman Telezhynskyi 2023-01-05 15:53:55 +02:00
parent e9ffd33d1a
commit 3bba41c07c

View File

@ -1,4 +1,5 @@
import qbs.FileInfo
import qbs.Utilities
Module {
property bool staticBuild: true
@ -146,14 +147,611 @@ Module {
cpp.treatWarningsAsErrors: true
}
property stringList debugFlags: {
var debugFlags = [];
if (qbs.toolchain.contains("gcc")) {
if (qbs.toolchain.contains("clang")) {
debugFlags.push(
"-fparse-all-comments",
"-Wabi",
"-Wabstract-final-class",
"-Wabstract-vbase-init",
"-Waddress",
"-Waddress-of-temporary",
"-Waggregate-return",
"-Wall",
"-Wambiguous-macro",
"-Wambiguous-member-template",
"-Wanalyzer-incompatible-plugin",
"-Wanonymous-pack-parens",
"-Warc",
"-Warc-bridge-casts-disallowed-in-nonarc",
"-Warc-maybe-repeated-use-of-weak",
"-Warc-non-pod-memaccess",
"-Warc-performSelector-leaks",
"-Warc-repeated-use-of-weak",
"-Warc-retain-cycles",
"-Warc-unsafe-retained-assign",
"-Warray-bounds",
"-Warray-bounds-pointer-arithmetic",
"-Wasm",
"-Wasm-operand-widths",
"-Wassign-enum",
"-Watomic-properties",
"-Watomic-property-with-user-defined-accessor",
"-Wattributes",
"-Wauto-import",
"-Wauto-storage-class",
"-Wauto-var-id",
"-Wavailability",
"-Wbackslash-newline-escape",
// "-Wbad-array-new-length",
"-Wbad-function-cast",
"-Wbind-to-temporary-copy",
"-Wno-c++98-compat-bind-to-temporary-copy",
"-Wbitfield-constant-conversion",
"-Wbitwise-op-parentheses",
"-Wbool-conversion",
"-Wbool-conversions",
"-Wbuiltin-macro-redefined",
"-Wbuiltin-requires-header",
"-Wc++-compat",
"-Wc++0x-compat",
"-Wc++0x-extensions",
"-Wc++0x-narrowing",
"-Wc++11-compat",
"-Wc++11-compat-pedantic",
"-Wc++11-compat-reserved-user-defined-literal",
"-Wc++11-extensions",
"-Wc++11-extra-semi",
"-Wc++11-long-long",
"-Wc++11-narrowing",
"-Wc11-extensions",
"-Wcast-align",
"-Wcast-of-sel-type",
"-Wcast-qual",
"-WCFString-literal",
"-Wchar-align",
"-Wchar-subscripts",
"-Wcomment",
"-Wcomments",
"-Wcompare-distinct-pointer-types",
"-Wcomplex-component-init",
"-Wconditional-type-mismatch",
"-Wconditional-uninitialized",
"-Wconfig-macros",
"-Wconstant-conversion",
"-Wconstant-logical-operand",
"-Wconstexpr-not-const",
"-Wconversion",
"-Wconversion-null",
"-Wno-covered-switch-default",
"-Wctor-dtor-privacy",
"-Wcustom-atomic-properties",
"-Wdangling-else",
"-Wdangling-field",
"-Wdangling-initializer-list",
"-Wdeclaration-after-statement",
"-Wdelegating-ctor-cycles",
"-Wdelete-incomplete",
"-Wdelete-non-virtual-dtor",
"-Wdeprecated",
"-Wdeprecated-declarations",
"-Wdeprecated-implementations",
"-Wdeprecated-objc-isa-usage",
"-Wdeprecated-objc-pointer-introspection",
"-Wdeprecated-objc-pointer-introspection-performSelector",
"-Wdeprecated-register",
"-Wdeprecated-writable-strings",
"-Wdirect-ivar-access",
// "-Wdisabled-macro-expansion", Disabled
"-Wdisabled-optimization",
"-Wdiscard-qual",
"-Wdistributed-object-modifiers",
"-Wdiv-by-zero",
"-Wdivision-by-zero",
"-Wdocumentation",
"-Wdocumentation-deprecated-sync",
"-Wdocumentation-html",
"-Wdollar-in-identifier-extension",
"-Wduplicate-decl-specifier",
"-Wduplicate-enum",
"-Wduplicate-method-arg",
"-Wduplicate-method-match",
"-Wdynamic-class-memaccess",
"-Weffc++",
"-Wembedded-directive",
"-Wempty-body",
"-Wempty-translation-unit",
"-Wendif-labels",
"-Wenum-compare",
"-Wenum-conversion",
"-Wexplicit-ownership-type",
"-Wextern-initializer",
"-Wextra",
"-Wextra-semi",
"-Wextra-tokens",
"-Wflexible-array-extensions",
"-Wfloat-equal",
"-Wformat",
"-Wformat-extra-args",
"-Wformat-invalid-specifier",
"-Wformat-non-iso",
"-Wformat-nonliteral",
"-Wformat-security",
"-Wformat-y2k",
"-Wformat-zero-length",
"-Wformat=2",
"-Wfour-char-constants",
"-Wgcc-compat",
"-Wgnu",
"-Wgnu-array-member-paren-init",
"-Wgnu-designator",
"-Wgnu-static-float-init",
"-Wheader-guard",
"-Wheader-hygiene",
"-Widiomatic-parentheses",
"-Wignored-attributes",
"-Wignored-qualifiers",
"-Wimplicit",
"-Wimplicit-atomic-properties",
"-Wimplicit-conversion-floating-point-to-bool",
"-Wimplicit-exception-spec-mismatch",
"-Wimplicit-fallthrough",
"-Wimplicit-fallthrough-per-function",
"-Wimplicit-function-declaration",
"-Wimplicit-int",
"-Wimplicit-retain-self",
"-Wimport",
"-Wimport-preprocessor-directive-pedantic",
"-Wincompatible-library-redeclaration",
"-Wincompatible-pointer-types",
"-Wincompatible-pointer-types-discards-qualifiers",
"-Wincomplete-implementation",
"-Wincomplete-module",
"-Wincomplete-umbrella",
"-Winit-self",
"-Winitializer-overrides",
// "-Winline",
"-Wint-conversion",
"-Wint-conversions",
"-Wint-to-pointer-cast",
"-Wint-to-void-pointer-cast",
"-Winteger-overflow",
"-Winvalid-constexpr",
"-Winvalid-iboutlet",
"-Winvalid-noreturn",
"-Winvalid-offsetof",
"-Winvalid-pch",
"-Winvalid-pp-token",
"-Winvalid-source-encoding",
"-Winvalid-token-paste",
"-Wknr-promoted-parameter",
"-Wlanguage-extension-token",
"-Wlarge-by-value-copy",
"-Wliteral-conversion",
"-Wliteral-range",
"-Wlocal-type-template-args",
"-Wno-c++98-compat-local-type-template-args",
"-Wlogical-not-parentheses",
"-Wlogical-op-parentheses",
// "-Wlong-long", // We have been using C++11
"-Wloop-analysis",
"-Wmain",
"-Wmain-return-type",
"-Wmalformed-warning-check",
"-Wmethod-signatures",
"-Wmicrosoft",
"-Wmicrosoft-exists",
"-Wmismatched-parameter-types",
"-Wmismatched-return-types",
"-Wmismatched-tags",
"-Wmissing-braces",
"-Wmissing-declarations",
"-Wmissing-field-initializers",
"-Wmissing-format-attribute",
"-Wmissing-include-dirs",
"-Wmissing-method-return-type",
"-Wmissing-noreturn",
"-Wmissing-prototypes",
"-Wmissing-selector-name",
"-Wmissing-sysroot",
"-Wmissing-variable-declarations",
"-Wmodule-conflict",
"-Wmost",
"-Wmultichar",
"-Wnarrowing",
"-Wnested-externs",
"-Wnewline-eof",
"-Wnon-gcc",
"-Wnon-literal-null-conversion",
"-Wnon-pod-varargs",
"-Wnon-virtual-dtor",
"-Wnonnull",
"-Wnonportable-cfstrings",
"-Wno-c++98-compat",
"-WNSObject-attribute",
"-Wnull-arithmetic",
"-Wnull-character",
"-Wnull-conversion",
"-Wnull-dereference",
"-Wodr",
"-Wold-style-cast",
"-Wold-style-definition",
"-Wout-of-line-declaration",
"-Wover-aligned",
"-Woverflow",
"-Woverlength-strings",
"-Woverloaded-shift-op-parentheses",
"-Woverloaded-virtual",
"-Woverriding-method-mismatch",
"-Wpacked",
"-Wparentheses",
"-Wparentheses-equality",
"-Wpedantic",
"-Wpointer-arith",
"-Wpointer-sign",
"-Wpointer-to-int-cast",
"-Wpointer-type-mismatch",
"-Wpredefined-identifier-outside-function",
"-Wprivate-extern",
"-Wprotocol",
"-Wprotocol-property-synthesis-ambiguity",
"-Wreadonly-iboutlet-property",
"-Wreceiver-expr",
"-Wreceiver-forward-class",
"-Wredundant-decls",
"-Wreinterpret-base-class",
"-Wreorder",
"-Wrequires-super-attribute",
"-Wreserved-user-defined-literal",
"-Wreturn-stack-address",
"-Wreturn-type",
"-Wreturn-type-c-linkage",
"-Wsection",
"-Wselector",
"-Wselector-type-mismatch",
"-Wself-assign",
"-Wself-assign-field",
"-Wsemicolon-before-method-body",
"-Wsentinel",
"-Wsequence-point",
"-Wserialized-diagnostics",
"-Wshadow-ivar",
"-Wshift-count-negative",
"-Wshift-count-overflow",
"-Wshift-op-parentheses",
"-Wshift-overflow",
"-Wshift-sign-overflow",
"-Wshorten-64-to-32",
"-Wsign-compare",
"-Wsign-conversion",
"-Wsign-promo",
"-Wsizeof-array-argument",
"-Wsizeof-array-decay",
"-Wsizeof-pointer-memaccess",
"-Wsometimes-uninitialized",
"-Wsource-uses-openmp",
// "-Wstack-protector",
"-Wstatic-float-init",
"-Wstatic-in-inline",
"-Wstatic-local-in-inline",
"-Wstatic-self-init",
"-Wstrict-aliasing",
"-Wstrict-aliasing=0",
"-Wstrict-aliasing=1",
"-Wstrict-aliasing=2",
"-Wstrict-overflow",
"-Wstrict-overflow=0",
"-Wstrict-overflow=1",
"-Wstrict-overflow=2",
"-Wstrict-overflow=3",
"-Wstrict-overflow=4",
"-Wstrict-overflow=5",
"-Wstrict-prototypes",
"-Wstrict-selector-match",
"-Wstring-compare",
"-Wstring-conversion",
"-Wstring-plus-int",
"-Wstrlcpy-strlcat-size",
"-Wstrncat-size",
"-Wsuper-class-method-mismatch",
"-Wswitch",
"-Wswitch-default",
"-Wsynth",
"-Wtautological-compare",
"-Wtautological-constant-out-of-range-compare",
"-Wtentative-definition-incomplete-type",
"-Wthread-safety",
"-Wthread-safety-analysis",
"-Wthread-safety-attributes",
"-Wthread-safety-beta",
"-Wthread-safety-precise",
"-Wtrigraphs",
"-Wtype-limits",
"-Wtype-safety",
"-Wtypedef-redefinition",
"-Wtypename-missing",
"-Wundeclared-selector",
"-Wundef",
"-Wundefined-inline",
"-Wundefined-internal",
"-Wundefined-reinterpret-cast",
"-Wunicode",
"-Wunicode-whitespace",
"-Wuninitialized",
"-Wunnamed-type-template-args",
"-Wunneeded-internal-declaration",
"-Wunneeded-member-function",
"-Wunsequenced",
"-Wunsupported-visibility",
"-Wunused",
"-Wunused-argument",
"-Wunused-command-line-argument",
"-Wunused-comparison",
"-Wunused-exception-parameter",
"-Wunused-function",
"-Wunused-label",
"-Wunused-member-function",
"-Wunused-parameter",
"-Wunused-private-field",
"-Wunused-result",
"-Wunused-value",
"-Wunused-variable",
"-Wunused-volatile-lvalue",
"-Wuser-defined-literals",
"-Wvarargs",
"-Wvariadic-macros",
"-Wvector-conversion",
"-Wvector-conversions",
"-Wvexing-parse",
"-Wvisibility",
"-Wvla",
"-Wvla-extension",
"-Wvolatile-register-var",
// "-Wweak-vtables",
"-Wwrite-strings",
"-Wzero-length-array",
"-Qunused-arguments",
"-fcolor-diagnostics",
"-Wno-gnu-zero-variadic-macro-arguments",
"-fms-extensions" // Need for pragma message
)
if (Utilities.versionCompare(cpp.compilerVersion, "14") < 0) {
debugFlags.push("-Wweak-template-vtables")
}
if (Utilities.versionCompare(cpp.compilerVersion, "13") >= 0) {
debugFlags.push(
"-Wreserved-identifier",
"-Wunused-but-set-parameter",
"-Wunused-but-set-variable"
)
}
if (Utilities.versionCompare(cpp.compilerVersion, "15") >= 0) {
debugFlags.push(
"-Warray-parameter"
)
}
if (qbs.targetOS.contains("macos")) {
// Cannot suppress warnings from Qt headers
debugFlags.push(
"-Wno-sign-conversion",
"-Wno-duplicate-enum",
"-Wno-shorten-64-to-32",
"-Wno-deprecated"
)
}
if (qbs.buildVariant === "release") {
debugFlags.push("-Wno-unknown-warning-option")
}
if (qbs.targetOS.contains("windows")) {
// Don't use additional keys on Windows system.
// Can't find a way to ignore Qt header on there.
debugFlags.push(
"-Wall",
"-Wextra",
"-pedantic",
"-Wno-gnu-zero-variadic-macro-arguments",
"-fms-extensions # Need for pragma message"
)
}
} else if (!qbs.toolchain.contains("clang")) {
debugFlags.push(
"-Wall",
"-Wextra",
"-pedantic",
"-Weffc++",
"-Woverloaded-virtual",
"-Wctor-dtor-privacy",
"-Wnon-virtual-dtor",
"-Wold-style-cast",
"-Wconversion",
"-Winit-self",
// "-Wstack-protector",
"-Wunreachable-code",
"-Wcast-align",
"-Wcast-qual",
"-Wdisabled-optimization",
"-Wfloat-equal",
"-Wformat=2",
"-Wimport",
// "-Wmissing-include-dirs",
"-Wpacked",
"-Wredundant-decls",
// "-Winline",
"-Winvalid-pch",
// "-Wunsafe-loop-optimizations",
// "-Wlong-long", // We have been using C++11
"-Wmissing-format-attribute",
"-Wswitch-default",
"-Wuninitialized",
"-Wvariadic-macros",
"-Wlogical-op",
"-Wnoexcept",
"-Wmissing-noreturn",
"-Wpointer-arith",
"-Wstrict-null-sentinel",
"-Wstrict-overflow=5",
"-Wno-error=strict-overflow",
"-Wundef",
"-Wno-unused",
"-Wno-pragmas"
)
if (Utilities.versionCompare(cpp.compilerVersion, "5") >= 0) {
debugFlags.push(
"-Wswitch-bool",
"-Wlogical-not-parentheses",
"-Wsizeof-array-argument",
// "-Wsuggest-final-types",
// "-Wsuggest-final-methods",
"-Wbool-compare"
)
}
if (Utilities.versionCompare(cpp.compilerVersion, "6") >= 0) {
debugFlags.push(
"-Wshift-negative-value",
"-Wshift-overflow",
"-Wshift-overflow=2",
"-Wtautological-compare",
// "-Wnull-dereference",
"-Wduplicated-cond",
"-Wmisleading-indentation"
)
}
if (Utilities.versionCompare(cpp.compilerVersion, "7") >= 0) {
debugFlags.push(
"-Wduplicated-branches",
"-Wrestrict",
"-Walloc-zero",
"-Wnonnull",
"-Wno-stringop-overflow" // cannot suppress warning in Qt headers
)
}
if (Utilities.versionCompare(cpp.compilerVersion, "8") >= 0) {
debugFlags.push(
"-Wmultistatement-macros",
"-Warray-bounds"
)
}
if (Utilities.versionCompare(cpp.compilerVersion, "10") >= 0) {
debugFlags.push(
"-Wredundant-tags"
)
}
if (Utilities.versionCompare(cpp.compilerVersion, "11") >= 0) {
debugFlags.push(
"-Wctad-maybe-unsupported",
"-Wmismatched-tags" // bugged in gcc 10
)
}
if (qbs.targetOS.contains("windows")) {
// Don't use additional keys on Windows system.
// Can't find a way to ignore Qt header on there.
debugFlags.push(
"-Wall",
"-Wno-pragmas",
"-Wno-error=strict-overflow",
"-Wextra"
)
if (Qt.core.versionMajor === 5 && Qt.core.versionMinor === 6) {
debugFlags.push(
"-Wno-array-bounds" // annoying warning
)
}
}
}
}
else if (qbs.toolchain.contains("msvc")) {
debugFlags.push(
"-Wall",
"-wd4061", // enum value is not *explicitly* handled in switch
"-wd4099", // first seen using 'struct' now seen using 'class'
"-wd4127", // conditional expression is constant
"-wd4217", // member template isn't copy constructor
"-wd4250", // inherits (implements) some member via dominance
"-wd4251", // needs to have dll-interface to be used by clients
"-wd4275", // exported class derived from non-exported class
"-wd4347", // "behavior change", function called instead of template
"-wd4355", // "'this': used in member initializer list
"-wd4505", // unreferenced function has been removed
"-wd4510", // default constructor could not be generated
"-wd4511", // copy constructor could not be generated
"-wd4512", // assignment operator could not be generated
"-wd4513", // destructor could not be generated
"-wd4514", // 'function' : unreferenced inline function has been removed
"-wd4610", // can never be instantiated user defined constructor required
"-wd4623", // default constructor could not be generated
"-wd4624", // destructor could not be generated
"-wd4625", // copy constructor could not be generated
"-wd4626", // assignment operator could not be generated
"-wd4640", // a local static object is not thread-safe
"-wd4661", // a member of the template class is not defined.
"-wd4670", // a base class of an exception class is inaccessible for catch
"-wd4672", // a base class of an exception class is ambiguous for catch
"-wd4673", // a base class of an exception class is inaccessible for catch
"-wd4675", // resolved overload was found by argument-dependent lookup
"-wd4702", // unreachable code, e.g. in <list> header.
"-wd4710", // call was not inlined
"-wd4711", // call was inlined
"-wd4820", // some padding was added
"-wd4917", // a GUID can only be associated with a class, interface or namespace
"-wd4351", // elements of array 'array' will be default initialized
// The following are real warnings but are generated by almost all MS headers, including
// standard library headers, so it's impractical to leave them on.
"-wd4619", // there is no warning number 'XXXX'
"-wd4668", // XXX is not defined as a preprocessor macro
"-wd5045", // Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified
// Because Microsoft doesn't provide a way to suppress warnings in headers we will suppress
// all warnings we meet in headers globally
"-wd4548",
"-wd4350",
"-wd4242",
"-wd4265",
"-wd4599",
"-wd4371",
"-wd4718",
"-wd4946",
"-wd4868", // compiler may not enforce left-to-right evaluation order in braced initializer list
"-wd4866", // compiler may not enforce left-to-right evaluation order for call to 'C++17 operator'
"-wd4571", // catch(...) semantics changed since Visual C++ 7.1; structured exceptions (SEH) are no longer caught
"-wd5026", // move constructor was implicitly defined as deleted
"-wd5027", // move assignment operator was implicitly defined as deleted
"-wd5039", // pointer or reference to potentially throwing function passed to extern C function under -EHc.
"-wd4774", // format string expected in argument 3 is not a string literal
"-wd5204", // class has virtual functions, but its trivial destructor is not virtual; instances of objects derived
// from this class may not be destructed correctly
"-wd5219", // implicit conversion from '<type>' to '<type>', possible loss of data
"-wd5243" // 'type-name': using incomplete class 'class-name' can cause potential one definition rule violation due
// to ABI limitation
)
}
return debugFlags;
}
cpp.cxxFlags: {
var flags = debugFlags;
if (qbs.toolchain.contains("gcc") && enableAddressSanitizer) {
flags.push("-fno-omit-frame-pointer");
}
return flags;
}
Properties {
condition: qbs.toolchain.contains("gcc")
cpp.cxxFlags: {
var flags = [];
if (enableAddressSanitizer)
flags.push("-fno-omit-frame-pointer");
return flags;
}
cpp.driverFlags: {
var flags = [];
if (enableAddressSanitizer)