// Copyright (C) 2024 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only

/*!
    \page creator-reference-preferences-cpp-quick-fixes.html
    \previouspage creator-reference.html

    \ingroup creator-reference-editors

    \title Quick Fixes

    \brief Set global preferences for C++ quick fixes.

    To set global preferences for C++ quick fixes, go to \preferences >
    \uicontrol C++ > \uicontrol {Quick Fixes}.

    \section1 Function Locations

    In the \uicontrol {Generated Function Locations} group, set
    whether quick fixes should generate getter and setter functions
    in the header file (inside or outside the class) or in the implementation
    file.

    \image {qtcreator-preferences-quick-fixes-function-locations.webp} {Generated Function Locations in the Quick Fixes tab in C++ preferences}

    \section1 Function Names and Attributes

    In the \uicontrol {Getter Setter Generation Properties} group,
    specify additional settings for getter and setter names, attributes, and
    parameters. You can specify that setter functions should be created as
    \e slots and that signals should be generated with the new value as a
    parameter.

    \image {qtcreator-refactoring-options-generation.png} {Getter and setter generation in the Quick Fixes tab in C++ preferences}

    \section1 Namespace Handling

    In the \uicontrol {Missing Namespace Handling} group, select whether to
    generate missing namespaces, add \c {using namespace} where necessary, or
    rewrite types to match the existing namespaces.

    \image {qtcreator-refactoring-options-namespaces.png} {Namespace handling in the Quick Fixes tab in C++ preferences}

    \section1 Custom Parameter Types

    In the \uicontrol {Custom Getter Setter Templates} group, specify how the
    code of a getter or setter function for a certain data type should look
    like. This is necessary for types where assignment cannot use \c operator=,
    as in the pre-defined settings for \c unique_ptr or where \c operator== is
    not suitable for comparison, as in the pre-defined settings for
    floating-point types. For example, if you have a special type \c MyClass,
    you can specify that a function, \c myCompare, should be used for comparison
    rather than the default of \c ==.

    To specify special handling for a custom parameter type, select
    \uicontrol Add and set the parameter type, comparison, return expression,
    and return type. In the \uicontrol {Return type} field, use \c <new>
    and \c <cur> to access the parameter and current value. Use \c <type> to
    access the type and \c <T> for the template parameter.

    \image {qtcreator-refactoring-options-templates.webp} {Handling custom parameter types in the Quick Fixes tab in C++ preferences}

    Usually, arguments are passed by using a \c const reference. To pass
    arguments of a particular type as values, list them in the
    \uicontrol {Value types} field. Namespaces and template arguments are
    removed. The real Type must contain the given Type. For example, \c int
    matches \c int32_t but not \c vector<int>, and \c vector matches
    \c {std::pmr::vector<int>} but not \c {std::optional<vector<int>>}.

    To return non-trivial objects by using a \c const reference, select
    \uicontrol {Return non-value types by const reference}.

    \sa {Apply quick fixes}, {Find symbols}, {Rename symbols},
    {Specify settings for quick fixes}, {C++ Quick Fixes}, {QML Quick Fixes}
*/

/*!
    \page creator-reference-cpp-quick-fixes.html
    \previouspage creator-reference.html

    \ingroup creator-reference-editors

    \title C++ Quick Fixes

    \brief Summary of quick fixes for C++ code.

    If you use the \l{Clang Code Model}{Clang code model} to parse the C++ files,
    you get \l{http://clang.llvm.org/diagnostics.html}{Clang fix-it hints} in the
    \uicontrol Edit mode. Use the standard ways of activating quick fixes, or
    select the fixes that are applicable on a line in the context menu in the
    left margin of the code editor.

   Apply the following types of quick fixes to C++ code:

   \list
        \li Change binary operands
        \li Simplify if and while conditions (for example, move declarations out
            of if conditions)
        \li Modify strings (for example, set the encoding for a string to
            Latin-1, mark strings translatable, and convert symbol names to
            camel case)
        \li Create variable declarations
        \li Create function declarations and definitions
   \endlist

    The following tables summarize the quick fixes available for C++ code,
    according to the cursor position.

    \section1 Block of Code Selected

    \table
        \header
            \li Quick Fix
            \li Description
        \row
            \li Assign to Local Variable
            \li Adds a local variable which stores the return value of a
                function call or a new expression. For example, rewrites

    \code
    QString s;
    s.toLatin1();
    \endcode

                as

    \code
    QString s;
    QByteArray latin1 = s.toLatin1();
    \endcode

                and

    \code
    new Foo;
    \endcode

                as

    \code
    Foo * localFoo = new Foo;
    \endcode

                By default, \QC uses the \c auto variable type when creating the
                variable. To label the variable with its actual type, select
                \preferences > \uicontrol C++ > \uicontrol {Quick Fixes} and
                clear \uicontrol {Use type "auto" when creating new variables}.

                Also available for a function call.
        \row
            \li Extract Function
            \li Moves the selected code to a new function and replaces the block
                of code with a call to the new function. Enter a name for the
                function in the \uicontrol {Extract Function Refactoring}
                dialog.
        \row
            \li Extract Constant as Function Parameter
            \li Replaces the selected literal and all its occurrences with the
                function parameter \c{newParameter}, which has the original
                literal as the default value.
    \endtable

    \section1 Class

    The following quick fixes are available when the cursor is on the definition
    of a class.

    \table
        \header
            \li Quick Fix
            \li Description
        \row
            \li Add #include
            \li Adds an \c {#include} directive to the project file to make a
                class available.
        \row
            \li Add #include and Project Dependency
            \li Adds an \c {#include} directive and package dependency to the
                project file to make an unknown Qt class available.
        \row
            \li Add definition
            \li Creates an empty class or struct definition from a forward
                declaration.
        \row
            \li Create Implementations for Member Functions
            \li Creates implementations for all member functions in one go.
                In the \uicontrol {Member Function Implementations} dialog,
                specify whether the member functions are generated
                inline or outside the class.
        \row
            \li Generate Constructor
            \li Creates a constructor for a class.
        \row
            \li Generate Missing Q_PROPERTY Members
            \li Adds missing members to a \c Q_PROPERTY:
            \list
                \li \c read function
                \li \c write function, if there is a WRITE
                \li \c {onChanged} signal, if there is a NOTIFY
                \li data member with the name \c {m_<propertyName>}
            \endlist
        \row
            \li Insert Virtual Functions of Base Classes
            \li Inserts declarations and the corresponding definitions inside or
                outside the class or in an implementation file (if it exists).
                For more information, see \l{Insert virtual functions}.
        \row
            \li Move All Function Definitions
            \li Moves all function definitions to the implementation file or
                outside the class. For example, rewrites
    \code
    class Foo
    {
      void bar()
      {
          // do stuff here
      }
      void baz()
      {
          // do stuff here
      }
    };
    \endcode

                as

    \code
    class Foo
    {
      void bar();
      void baz();
    };

    void Foo::bar() {
        // do stuff here
    }

    void Foo::baz() {
        // do stuff here
    }
    \endcode
    \row
        \li Move Class to a Dedicated Set of Source Files
        \li Moves a class to separate header and source files. For more
            information, see \l{Move classes to separate files}.
    \row
        \li Re-order Member Function Definitions According to Declaration Order
        \li Re-orders method definitions in a \c .cpp file to follow the order of
            method declarations in the corresponding \c .h file.
    \endtable

    \section1 Class Member

    The following quick fixes are available when the cursor is on a member
    variable in a class definition.

    \table
        \header
            \li Quick Fix
            \li Description
        \row
            \li Generate Constant Q_PROPERTY and Missing Members
            \li Generates a constant Q_PROPERTY and adds missing members
                to it.
        \row
            \li Generate Getter
            \li Creates a getter member function for a member variable.
        \row
            \li Generate Getter and Setter
            \li Creates getter and setter member functions for a member
                variable.
        \row
            \li Create Getter and Setter Member Functions
            \li Creates either both getter and setter member functions for
                member variables or only a getter or setter.
        \row
            \li Generate Q_PROPERTY and Missing Members
            \li Generates a Q_PROPERTY and adds missing members to it.
        \row
            \li Generate Q_PROPERTY and Missing Members with Reset Function
            \li Generates a Q_PROPERTY and adds missing members to it, with an
                additional \c reset function.
        \row
            \li Generate Setter
            \li Creates a setter member function for a member variable.
    \endtable

    \section1 Control Statement

    \table
        \header
            \li Quick Fix
            \li Description
        \row
            \li Add Curly Braces
            \li Adds curly braces to an if clause or to a do, while, or for
                loop. For example, rewrites an if clause

    \code
    if (a)
        b;
    else
        c;
    \endcode

                as

    \code
    if (a) {
        b;
    } else {
        c;
    }
    \endcode

    Rewrites a do loop

    \code
    do
        ++i;
    while (i < 10);
    \endcode

                as

    \code
    do {
        ++i;
    } while (i < 10);
    \endcode

    Rewrites a while loop

    \code
    while (i > 0)
        --i;
    \endcode

            as

    \code
    while (i > 0) {
        --i;
    }
    \endcode

    Rewrites a for loop

    \code
    for (int i = 0; i < 10; ++i)
        func(i);
    \endcode

            as

    \code
    for (int i = 0; i < 10; ++i) {
         func(i);
    }
    \endcode
        \row
            \li Remove Curly Braces
            \li Removes curly braces from a block that consists of a single
                statement.
        \row
            \li Complete Switch Statement
            \li Adds all possible cases to a switch statement of the type
                \c enum.
        \row
            \li Move Declaration out of Condition
            \li Moves a declaration out of an if or while condition to simplify
                the condition. For example, rewrites

    \code
    if (Type name = foo()) {}
    \endcode

                as

    \code
    Type name = foo;
    if (name) {}
    \endcode
        \row
            \li Optimize for-Loop
            \li Rewrites post-increment operators as pre-increment operators and
                post-decrement operators as pre-decrement operators. It also
                moves other than string or numeric literals and id expressions
                from the condition of a for loop to its initializer. For
                example, rewrites

    \code
    for (int i = 0; i < 3 * 2; i++)
    \endcode

                as

    \code
    for (int i = 0, total = 3 * 2; i < total; ++i)
    \endcode
    \endtable

    \section1 Function Declaration or Definition

    \table
        \header
            \li Quick Fix
            \li Description
        \row
            \li Add Definition ...
            \li Inserts a definition stub for a function declaration either in
                the header file (inside or outside the class) or in the
                implementation file. For free functions, inserts the definition
                after the declaration of the function or in the implementation
                file. Qualified names are minimized when possible, instead of
                always being fully expanded.

                For example, rewrites

    \code
    Class Foo {
        void bar();
    };
    \endcode

                as (inside class)

    \code
    Class Foo {
        void bar() {

        }
    };
    \endcode

                as (outside class)

    \code
    Class Foo {
        void bar();
    };

    void Foo::bar()
    {

    }
    \endcode

                as (in implementation file)

    \code
    // Header file
    Class Foo {
        void bar();
    };

    // Implementation file
    void Foo::bar()
    {

    }
    \endcode
        \row
            \li Add \c Function Declaration
            \li Inserts the member function declaration that matches the member
                function definition into the class declaration. The function can
                be \c {public}, \c {protected}, \c {private}, \c {public slot},
                \c {protected slot}, or \c {private slot}.
       \row
            \li Apply Changes
            \li Keeps function declarations and definitions synchronized by
                checking for the matching declaration or definition when you
                edit a function signature and by applying the changes to the
                matching code.

                When this fix is available, a light bulb icon appears:
                \inlineimage {icons/refactormarker.png} {Light bulb icon}
        \row
            \li Convert Function Call to Qt Meta-Method Invocation
            \li Converts an invocable function call into a meta method
                invocation. This applies to signals and slots in general,
                as well as functions explicitly marked with \c Q_INVOKABLE.
                For example, for the following class:
    \code
    class Foo : public QObject
    {
        Q_OBJECT
    public:
        explicit Foo(QObject *parent = nullptr);

        Q_SLOT void pubBar(int i);

    private:
        Q_INVOKABLE void bar(int i, const QString &c);
    };
    \endcode

                rewrites

    \code
    Foo::Foo(QObject *parent)
        : QObject{parent}
    {
        this->bar(42, QString("answer"));
    }
    \endcode

                as

    \code
    Foo::Foo(QObject *parent)
        : QObject{parent}
    {
        QMetaObject::invokeMethod(this, "bar", Q_ARG(int, 42), Q_ARG(QString, QString("answer")));
    }
    \endcode

    The quick fix also works on invocable methods outside the class that are
    visible from the location where they are called from. For example, it
    rewrites

    \code
    Foo f;
    f.pubBar(123);
    \endcode

    as

    \code
    Foo f;
    QMetaObject::invokeMethod(&f, "pubBar", Q_ARG(int, 123));
    \endcode
        \row
            \li Move Definition Here
            \li Moves an existing function definition to its declaration.
        \row
            \li Move Function Definition
            \li Moves a function definition to the implementation file, outside
                the class or back to its declaration. For example, rewrites
    \code
    class Foo
    {
      void bar()
      {
          // do stuff here
      }
    };
    \endcode

                as
    \code
    class Foo
    {
      void bar();
    };

    void Foo::bar() {
        // do stuff here
    }
    \endcode
        \row
            \li Move Function Documentation to Declaration/Definition
            \li Moves the documentation comment for a function between its
                declaration and definition.
    \endtable

    \section1 Identifier

    \table
        \header
            \li Quick Fix
            \li Description
        \row
            \li Add #include for undeclared or forward declared identifier
            \li Adds an \c {#include} directive to the current file to make the
                definition of a symbol available.
        \row
            \li Add Class Member
            \li Adds a member declaration for the class member being
                initialized if it is not yet declared. If \QC cannot
                automatically detect the data type of the member, you
                must add it.
        \row
            \li Add Definition
            \li Inserts a definition stub for a static data member.
        \row
            \li Add Forward Declaration
            \li Adds a forward declaration for an undeclared identifier
                operation.
        \row
            \li Convert to Camel Case
            \li Converts a symbol name to camel case, where elements of the name
                are joined without delimiter characters and the initial
                character of each element is capitalized. For example, rewrites
                \c an_example_symbol as \c anExampleSymbol and
                \c AN_EXAMPLE_SYMBOL as \c AnExampleSymbol
    \endtable

    \section1 Numeric Literal

    \table
        \header
            \li Quick Fix
            \li Description
        \row
            \li Convert to Decimal
            \li Converts an integer literal to decimal representation
        \row
            \li Convert to Hexadecimal
            \li Converts an integer literal to hexadecimal representation
        \row
            \li Convert to Octal
            \li Converts an integer literal to octal representation
    \endtable

    \section1 Operator

    \table
        \header
            \li Quick Fix
            \li Description
            \li Operator

        \row
            \li Rewrite Condition Using ||
            \li Rewrites the expression according to De Morgan's laws. For
                example, rewrites
    \code
    !a && !b
    \endcode

                as

    \code
    !(a || b)
    \endcode
            \li \c &&
        \row
            \li Rewrite Using \e operator
            \li Rewrites an expression negating it and using the inverse
                operator. For example, rewrites

            \list

    \li    \code
    a op b
    \endcode

                as

    \code
    !(a invop b)
    \endcode

    \li    \code
    (a op b)
    \endcode

                as

    \code
    !(a invop b)
    \endcode

    \li   \code
    !(a op b)
    \endcode

                as

    \code
    (a invob b)
    \endcode

    \endlist

            \li \c {<=}, \c {<}, \c {>}, \c {>=}, \c {==} or \c {!=}
        \row
            \li Split if Statement
            \li Splits an if statement into several statements. For example,
                rewrites

    \code
    if (something && something_else) {
    }
    \endcode

                as

    \code
    if (something) {
       if (something_else) {
       }
    }
    \endcode

                and

    \code
    if (something || something_else)
        x;
    \endcode

                with

    \code
    if (something)
        x;
    else if (something_else)
        x;
    \endcode

            \li \c && or \c ||
        \row
            \li Swap Operands
            \li Rewrites an expression in the inverse order using the inverse
                operator. For example, rewrites
    \code
    a op b
    \endcode

                as
    \code
    b flipop a
    \endcode
            \li \c {<=}, \c {<}, \c {>},  \c {>=}, \c {==}, \c {!=}, \c {&&}
                or \c {||}
    \endtable

    \section1 String Literal

    \table
        \header
            \li Quick Fix
            \li Description
        \row
            \li Append Operator
            \li Adds a string literal operator (\c {QByteArrayLiteral},
                \c {QLatin1Char}, \c {QLatin1String}, or \c {QStringLiteral}),
                such as \c {"_ba"} or \c {"_L1"} to a string literal.
        \row
            \li Convert to Character Literal
            \li Converts a single-character string literal into a character
                literal, with some special cases. For example,

    \code
    "a"
    "'"
    "\n"
    "\""
    \endcode

                are converted to

    \code
    'a'
    '\''
    '\n'
    '"'
    \endcode
        \row
            \li Convert to Objective-C String Literal
            \li Converts a string literal to an Objective-C string literal if
                the file type is Objective-C(++). For example, rewrites the
                following strings

    \code
    "abcd"
    QLatin1String("abcd")
    QLatin1Literal("abcd")
    \endcode

                as

    \code
    @"abcd"
    \endcode
        \row
            \li Convert to String Literal
            \li Converts a character literal into a string literal, with some
                special cases. For example,

    \code
    'a'
    '\''
    '\n'
    '"'
    \endcode

                are converted to

    \code
    "a"
    "'"
    "\n"
    "\""
    \endcode
        \row
            \li Enclose in QByteArrayLiteral()
            \li Converts a string to a byte array. For example, rewrites
    \code
    "abcd"
    \endcode

                as

    \code
    QByteArrayLiteral("abcd")
    \endcode
        \row
            \li Enclose in QLatin1Char()
            \li Sets the encoding for a character to Latin-1, unless the
                character is already enclosed in QLatin1Char, QT_TRANSLATE_NOOP,
                tr, trUtf8, QLatin1Literal, or QLatin1String. For example,
                rewrites

    \code
    'a'
    \endcode

                as

    \code
    QLatin1Char('a')
    \endcode
        \row
            \li Enclose in QLatin1String()
            \li Sets the encoding for a string to Latin-1, unless the string is
                already enclosed in QLatin1Char, QT_TRANSLATE_NOOP, tr, trUtf8,
                QLatin1Literal, or QLatin1String. For example, rewrites
    \code
    "abcd"
    \endcode

                as

    \code
    QLatin1String("abcd")
    \endcode
        \row
            \li Escape String Literal as UTF-8
            \li Escapes non-ASCII characters in a string literal to hexadecimal
                escape sequences. String Literals are handled as UTF-8.
        \row
            \li Mark as Translatable
            \li Marks a string translatable. For example, rewrites \c "abcd"
                with one of the following options, depending on which of them is
                available:

    \code
    tr("abcd")
    QCoreApplication::translate("CONTEXT", "abcd")
    QT_TRANSLATE_NOOP("GLOBAL", "abcd")
    \endcode
        \row
            \li Unescape String Literal as UTF-8
            \li Unescapes octal or hexadecimal escape sequences in a string
                literal. String Literals are handled as UTF-8.
    \endtable

    \section1 \c using directive

    \table
        \header
            \li Quick Fix
            \li Description
       \row
            \li Remove All Occurrences of \c {using namespace} in Global Scope
                and Adjust Type Names Accordingly
            \li Remove all occurrences of \c {using namespace} in the global
                scope and adjust type names accordingly.
        \row
            \li Remove \c {using namespace} and Adjust Type Names Accordingly
            \li Remove occurrences of \c {using namespace} in the local scope
                and adjust type names accordingly.
    \endtable


    \section1 Miscellaneous

    \table
        \header
            \li Quick Fix
            \li Description
            \li Activation
        \row
            \li Add Local Declaration
            \li Adds the type of an assignee, if the type of the right-hand
                side of the assignment is known. For example, rewrites

    \code
    a = foo();
    \endcode

                as

    \code
    Type a = foo();
    \endcode

                where Type is the return type of \c {foo()}

            \li Assignee
        \row
            \li Add Project Dependency
            \li Adds the missing package dependency for a missing included Qt
                file to the project file.
            \li #include statements for Qt classes
        \row
            \li Convert connect() to Qt 5 Style
            \li Converts a Qt 4 QObject::connect() to Qt 5 style.
            \li QObject::connect() (Qt 4 style)
        \row
            \li Convert Comment to C/C++ Style
            \li Converts C-style comments into C++-style comments, and vice
                versa. Tries to preserve \e pretty layout and takes Doxygen and
                qdoc formatting into consideration, but you might need to clean
                up the results.
            \li Code comment
        \row
            \li Convert to Pointer
            \li Converts the selected stack variable to a pointer. For example,
                rewrites

    \code
    QByteArray foo = "foo";
    foo.append("bar");
    \endcode

                as

    \code
    QByteArray *foo = new QByteArray("foo");
    foo->append("bar");
    \endcode

                This operation is limited to work only within function scope.
                Also, the coding style for pointers and references is not
                respected yet.
            \li Stack Variable
        \row
            \li Convert to Stack Variable
            \li Converts the selected pointer to a stack variable. For example,
                rewrites

    \code
    QByteArray *foo = new QByteArray("foo");
    foo->append("bar");
    \endcode

                as

    \code
    QByteArray foo("foo");
    foo.append("bar");
    \endcode

                This operation is limited to work only within function scope.
                Also, the coding style for pointers and references is not
                respected yet.
            \li Pointer Variable
        \row
            \li Reformat Pointers or References
            \li Reformats declarations with pointers or references according
                to the code style settings for the current project. In case no
                project is open, the current global code style settings are
                used.

                For example, rewrites

    \code
    char*s;
    \endcode

                as

    \code
    char *s;
    \endcode

                When applied to selections, all suitable declarations in the
                selection are rewritten.

            \li Declarations with pointers or references and selections
                that have such declarations
        \row
            \li Split Declaration
            \li Splits a simple declaration into several declarations. For
                example, rewrites
    \code
    int *a, b;
    \endcode

                as

    \code
    int *a;
    int b;
    \endcode
            \li Type name or variable name
        \row
            \li Switch with Next/Previous Parameter
            \li Moves a parameter down or up one position in a parameter list.
            \li Parameter in the declaration or definition of a function
    \endtable

    \sa {Apply quick fixes}, {Find symbols}, {Rename symbols},
    {Specify settings for quick fixes}, {QML Quick Fixes}, {Quick Fixes}
*/

/*!
    \page creator-how-to-specify-settings-for-quick-fixes.html
    \previouspage creator-how-tos.html

    \ingroup creator-how-to-projects-configure

    \title Specify settings for quick fixes

    To refactor your code, select quick fixes in the context menu in the
    \uicontrol Edit mode.

    To create custom quick fix settings for a particular project, go to
    \uicontrol Projects > \uicontrol {Project Settings} >
    \uicontrol {Quick Fixes} and clear \uicontrol {Use global settings}.

    \image {qtcreator-refactoring-options-locations.png} {Quick Fixes preferences for a project}

    To revert to global settings, select \uicontrol {Reset to Global}. To
    delete the custom settings, select \uicontrol {Use global settings}, and
    then select \uicontrol {Delete Custom Settings File}.

    \sa {Apply quick fixes}, {Find symbols}, {Rename symbols},
    {C++ Quick Fixes}, {QML Quick Fixes}, {Quick Fixes}, {Building and running projects}
*/
