# A --> B        option A implies option B
# A --> B C      option A implies options B and C
# A && B --> C   options A and B together imply C

# A <-- B        option A is implied by option B.
# A <-- B || C   option A is implied by either option B or option C
# A <-- B && C   option A is implied by options B and C together

# A ==> B        option A enables option B
# A ==> B C      option A enables options B and C
# A <== B        option A requires option B (depends on B)

default --> -Wimport -Wdiv-by-zero -Wendif-labels -Wattributes -Wmultichar
            -Wnormalized=nfc -Wdeprecated-declarations -Winvalid-offset-of
            -Wint-to-pointer-cast -Wpointer-to-int-cast -Woverflow

default (C++) --> -Wwrite-strings

-fsyntax-only

-pedantic --> -Wlong-long -Wvariadic-macros -Wpointer-sign -Woverlength-strings

-pedantic <-- -pedantic-errors

-pedantic-errors --> -pedantic

-w

-Wimport <-- default

-Wchar-subscripts <-- -Wall

-Wcomment <-- -Wall

-Wfatal-errors

-Wformat --> -Wnonnull -Wformat-extra-args -Wformat-zero-length
-Wformat <-- -Wformat=2 || -Wall
-Wformat ==> -Wformat-y2k -Wformat-nonliteral -Wformat-security

-Wformat-y2k <== -Wformat

-Wno-format-extra-args <== -Wformat # false dependency

-Wno-format-zero-length <== -Wformat # false dependency

-Wformat-nonliteral <== -Wformat

-Wformat-security <== -Wformat

-Wformat=2 --> -Wformat -Wformat-y2k -Wformat-nonliteral -Wformat-security

-Wnonnull <-- -Wall || -Wformat

-Winit-self <== -Wuninitialized # depends not only on -O1, but -O(1|2|3|s)

-Wimplicit-int <-- -Wall

-Wimplicit-function-declaration <-- -Wall

-Werror-implicit-function-declaration

-Wimplicit --> -Wimplicit-int -Wimplicit-function-declaration
-Wimplicit <-- -Wall # redundant implication

-Wmain <-- -Wall

-Wmissing-braces <-- -Wall

-Wmissing-include-dirs

-Wparentheses <-- -Wall

-Wsequence-point <-- -Wall

-Wreturn-type <-- -Wall

-Wswitch <-- -Wall

-Wswitch-default

-Wswitch-enum

-Wtrigraphs <-- -Wall

-Wunused-function <-- -Wall

-Wunused-label <-- -Wall

-Wunused-parameter <-- -Wextra && -Wunused
-Wunused-parameter <-- -Wextra && -Wall # redundant implication

-Wunused-variable <-- -Wall

-Wunused-value <-- -Wall

-Wunused --> -Wtrigraphs -Wunused-function -Wunused-label -Wunused-variable
             -Wunused-value
-Wunused <-- -Wall # redundant implication

-Wuninitialized <-- -Wall
-Wuninitialized ==> -Winit-self
-Wuninitialized <== -O(1|2|3|s)

-Wunknown-pragmas <== -Wsystem-headers # undocumented

-Wpragmas <-- -Wall # missing "This warning is enabled by `-Wall'".

-Wstrict-aliasing <-- -Wall || -Wstrict-aliasing=2

-Wstrict-aliasing=2 --> -Wstrict-aliasing
-Wstrict-aliasing=2 <== -fstrict-aliasing

-Wall --> -Walways-true -Wchar-subscripts -Wcomment -Wformat -Wnonnull -Wimplicit-int
          -Wimplicit-function-declaration -Wimplicit -Wmain -Wmissing-braces
          -Wparentheses -Wsequence-point -Wreturn-type -Wswitch -Wtrigraphs
          -Wunused-function -Wunused-label -Wunused-variable -Wunused-value
          -Wunused -Wuninitialized -Wpragmas -Wstrict-aliasing
	  -Wpointer-sign -Wstring-literal-comparison

# clearly not "All of the above -W options combined."
# note that -Wpointer-sign is also below this point.

-W --> -Wextra

-Wextra --> -Wsign-compare -Wold-style-declaration -Woverride-init 
            -Wmissing-parameter-type -Wmissing-field-initializers 
            -Wempty-body -Wclobbered 
            
# do we have -Wextra --> -Wconversion now too?

-Wextra && -Wunused --> -Wunused-parameter # s/arguments/parameters/
-Wextra && -Wall --> -Wunused-parameter # redundant implication

-Wdiv-by-zero <-- default

-Wsystem-headers ==> -Wunknown-pragmas

-Wfloat-equal

-Wtraditional

-Wtraditional-conversion

-Wdeclaration-after-statement

-Wundef

-Wendif-labels <-- default

-Wshadow

-Wlarger-than-LEN

-Wunsafe-loop-optimizations

-Wpointer-arith

-Wbad-function-cast

-Wc++-compat

-Wcast-qual

-Wcast-align

-Wwrite-strings <-- default (C++)

-Wclobbered <-- -Wextra

-Wconversion # do we have -Wconversion <-- -Wextra now?

-Wempty-body <-- -Wextra

-Wsign-compare <-- -Wextra

-Waggregate-return

-Walways-true <-- -Wall

-Wattributes <-- default

-Wstrict-prototypes

-Wold-style-declaration <-- -Wextra

-Wold-style-definition

-Wmissing-parameter-type <-- -Wextra

-Wmissing-prototypes

-Wmissing-declarations

-Wmissing-field-initializers <-- -Wextra

-Wmissing-noreturn

-Wmissing-format-attribute

-Wmultichar <-- default

-Wnormalized=none

-Wnormalized=id

-Wnormalized=nfc <-- default

-Wnormalized=nfkc

-Wdeprecated-declarations <-- default

-Woverflow <-- default

-Woverride-init <-- -Wextra

-Wpacked

-Wpadded

-Wredundant-decls

-Wnested-externs

-Wunreachable-code

-Winline

-Winvalid-offset-of <-- default

-Wint-to-pointer-cast <-- default

-Wpointer-to-int-cast <-- default

-Winvalid-pch

-Wlong-long <-- default   # not actually the case
-Wlong-long <== -pedantic # should be <-- pedantic

-Wvariadic-macros <-- default # not actually the case
-Wvariadic-macros <-- -pedantic

-Wvolatile-register-var

-Wdisabled-optimization

-Wpointer-sign <-- -Wall || -pedantic

-Werror

-Werror= # note: -Werror=foo --> -Wfoo

-Wstack-protector <== -fstack-protector

-Wstring-literal-comparison <-- -Wall

-Woverlength-strings <-- -pedantic