draft new linter topics

Author: TylerMSFT

docs/ide/lnt-int-naming-convention.md

@@ -1,78 +1,71 @@
 ---
-title: lnt-int-naming-convention
-description: "Reference for Visual Studio C++ IntelliSense Linter check lnt-int-naming-convention."
-ms.date: 09/29/2021
-f1_keywords: ["lnt-int-naming-convention"]
-helpviewer_keywords: ["lnt-int-naming-convention"]
-monikerRange: ">=msvc-160"
+title: int-naming-convention
+description: "Reference for Visual Studio C++ IntelliSense Linter check int-naming-convention."
+ms.date: 09/27/2023
+f1_keywords: ["int-naming-convention"]
+helpviewer_keywords: ["int-naming-convention"]
+monikerRange: ">=msvc-170"
 ---
-# `lnt-int-naming-convention`
+# `int-naming-convention`
 
-A copy is being made because `auto` doesn't deduce references.
+Ensure that the naming convention for symbols aligns with the coding style specified in the project's `.editorconfig` file.
 
-Variables declared by using `auto` are never deduced to be type references. If you initialize an `auto` variable from the result of a function that returns by reference, it results in a copy. Sometimes this effect is desirable, but in many cases it causes an unintentional copy.
+To enable this feature, add an `.editorconfig` file in the same directory as your project file. The `.editorconfig` specifies the naming conventions for symbols in your project. For an example `.editorconfig` that specifies the naming conventions for Unreal Engine projects, see [`.editorconfig` on ](https://raw.githubusercontent.com/microsoft/vc-ue-extensions/main/Source/.editorconfig).
 
-The `lnt-int-naming-convention` check is controlled by the **Accidental Copy** setting in the C/C++ Code Style options. For information on how to change this setting, see [Configure the linter](cpp-linter-overview.md#configure-the-linter).
+Once you have the `.editorconfig` file in your project, turn on the `int-naming-convention` check with the **Naming Convention** setting in the C/C++ Code Style options. For information about how to change this setting, see [Configure the linter](cpp-linter-overview.md#configure-the-linter).
 
-## Examples
+## Example
+
+The For example, an `editorconfig` file that contains:
 
 ```cpp
-#include <string>
-#include <vector>
+class MyClass
+{ 
 
-std::string& return_by_ref();
+public: 
 
-int& return_int_by_ref();
+  int getValue() { return value; }  // Flagged: ‘getValue’ doesn't modify the object's state. 
 
-void accidental_copy(std::vector<std::string>& strings)
-{
-    for (auto s : strings) {} // Flagged: A new copy of each string is
-                              // made when the vector is iterated.
+  void setValue(int newValue) { value = newValue; }  // OK: ‘setValue’ modifies the object's state.   
 
-    auto s = return_by_ref(); // Flagged: the function returns by-reference
-                              // but a copy is made to initialize 's'.
+private: 
 
-    auto i = return_int_by_ref(); // Not flagged because no copy constructor is called.
-}
-```
+  int value = 42; 
 
-## How to fix the issue
+}; 
+``````
 
-The fix the linter suggests is to change `auto` to `auto&` on the declaration.
+flags the following code:
 
 ```cpp
-#include <string>
-
-std::string& return_by_ref();
-
-void accidental_copy(std::vector<std::string>& strings)
+void example()
 {
-    for (auto& s : strings) {}
-
-    auto& s = return_by_ref();
+    bool myFlag = true; // flagged because it doesn't follow the naming convention specified in the .editorconfig
 }
 ```
 
-## Remarks
+## How to fix the issue
 
-The suggested fix isn't safe to apply in all cases. The fix may cause a compilation error or change the behavior of the code. It's important to understand how the suggested fix affects the code before applying it.
+Change the naming based on the code style specified in the `.editorconfig`. For example:
 
-In cases where a temporary is returned, `const auto&` is necessary to prevent a compilation error. In this case, it may be preferable to continue to use `auto`.
+```cpp
+void example()
+{ 
+    bool bMyFlag = true; // fixed to follow the code style specified in the .editorconfig
+} 
+```
 
-Sometimes a copy is intentional, such as when you want to modify the copy without affecting the source instance, as shown in this example.
+The editor can make the change for you. Place the cursor on the flagged symbol, and choose **Show potential fixes** and then **Apply naming convention**:
 
-```cpp
-void modifies_string(std::string& s);
+:::image type="content" source="media/int-naming-convention-apply-naming-convention.png" :::
+The code editor shows bool myFlag = true. With the cursor on that line of code, **Show potential fixes** appeared and was chosen. Now **Apply naming convention** is visible and it shows bool my Flag = true in red and the suggested change, bool b My Flag, in green. You can now choose **Apply naming convention** to change the flagged code to bool b My Flag = true.
+:::image-end:::
 
-void example(std::vector<std::string>& strings)
-{
-    for (auto s : strings) {
-        modifies_string(s);    // In this case, the copy may be intended so that
-                               // the original strings are not modified.
-    }
-}
-```
+## Remarks
+
+The `int-naming-convention` linter check ensures that naming conventions align with naming conventions specified in the `editorconfig` file. This check check can be applied to any project that has an `editorconfig` file, and can customize your `.editorconfig` file to suit your project's coding style.
 
 ## See also
 
-[IntelliSense code linter for C++ overview](cpp-linter-overview.md)
+[Create portable, custom editor settings with EditorConfig](/visualstudio/ide/create-portable-custom-editor-options)\
+[IntelliSense code linter for C++ overview](cpp-linter-overview.md)

docs/ide/lnt-make-member-function-const.md

@@ -0,0 +1,74 @@
+---
+title: make-member-function-const
+description: "Reference for Visual Studio C++ IntelliSense Linter check make-member-function-const."
+ms.date: 09/27/2023
+f1_keywords: ["make-member-function-const"]
+helpviewer_keywords: ["make-member-function-const"]
+monikerRange: ">=msvc-170"
+---
+# `make-member-function-const`
+
+When member functions don’t modify their object state, mark them as const. This guidance comes from the [C++ Core Guideline Con.2](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#con2-by-default-make-member-functions-const).
+
+## Example
+
+```cpp
+class MyClass
+{ 
+public: 
+
+  int getValue() { return value; }  // Flagged: ‘getValue’ doesn't modify the object's state. 
+
+  void setValue(int newValue) { value = newValue; }  // OK: ‘setValue’ modifies the object's state.   
+
+private: 
+
+  int value = 42; 
+
+}; 
+
+double getRadius()
+{   // Flagged: ‘getRadius’ doesn't modify the object's state. 
+    return radius; 
+} 
+```
+
+## How to fix the issue
+
+The solution proposed by the linter is to mark member functions `const` when they do not modify the object's state. This provides a clear indication to both developers and the compiler that the function is safe to call on `const` objects. In the following example, `const` has been added to `getValue()` and `getRadius()`:
+
+```cpp
+class MyClass
+{ 
+public: 
+
+  int getValue() const { return value; }  // Added const 
+  void setValue(int newValue) { value = newValue; }  // OK: ‘setValue’ modifies the object's state.   
+
+private: 
+
+  int value = 42; 
+
+}; 
+
+double getRadius() const // added const
+{   // ‘getRadius’ doesn't modify the object's state. 
+    return radius; 
+}  
+```
+
+The editor can make this change for you. Place the cursor on the flagged symbol, and choose **Show potential fixes** and then **Make member const**:
+
+:::image type="content" source="media/make-member-function-const.png" :::
+The cursor is on the line int getValue() and **Show potential fixes** appeared and was chosen. Now **Make member const** is visible and it shows the get value function with const added to it. You can now choose **Make member const** to change make the change.
+:::image-end:::
+
+## Remarks
+
+This check focuses on `const` usage for member functions in C++ code. The C++ Core Guidelines recommends marking member functions as `const` when they do not modify the object's state.
+
+The current implementation of this check allows for the assignment of `const` to member functions after their declaration. However, it is a good practice to declare member functions as `const` from the beginning if they do not modify the object's state.
+
+## See also
+
+[IntelliSense code linter for C++ overview](cpp-linter-overview.md)

docs/ide/media/int-naming-convention-apply-naming-convention.png

@@ -30,10 +30,12 @@ items:
         href: ../ide/lnt-integer-float-division.md
       - name: lnt-logical-bitwise-mismatch
         href: ../ide/lnt-logical-bitwise-mismatch.md
-      - name: lnt-naming-convention
-        href: ../ide/lnt-naming-convention.md
+      - name: lnt-int-naming-convention
+        href: ../ide/lnt-int-naming-convention.md
       - name: lnt-uninitialized-local
         href: ../ide/lnt-uninitialized-local.md
+      - name: lnt-make-member-function-const
+        href: ../ide/lnt-make-member-function-const.md
     - name: Change signature
       href: ../ide/refactoring/change-signature.md
     - name: Convert to raw string literal