Merge pull request #4477 from MicrosoftDocs/master

4/18/2019 AM Publish

Author: Taojunshen

.markdownlint.json

@@ -2,25 +2,20 @@
     "default": true,
     "MD001": false,
     "MD002": false,
-    "MD003": false,
     "MD004": false,
     "MD005": false,
     "MD006": false,
     "MD007": false,
     "MD009": false,
     "MD011": false,
     "MD013": false,
-    "MD019": false,
-    "MD020": false,
     "MD022": false,
     "MD024": false,
     "MD025": false,
     "MD026": false,
     "MD027": false,
     "MD028": false,
     "MD029": false,
-    "MD030": false,
-    "MD031": false,
     "MD032": false,
     "MD033": {
         "allowed_elements": [

docs/ai/installation.md

@@ -81,6 +81,7 @@ Deep learning frameworks rely on pip for their own installation.
 Then, we need to verify whether Python 3.5 is installed correctly, and upgrade pip to the latest version by executing the following commands in a terminal:
 
 - **Windows**
+
     ```cmd
     C:\Users\test>python -V
     Python 3.5.4
@@ -92,6 +93,7 @@ Then, we need to verify whether Python 3.5 is installed correctly, and upgrade p
     ```
 
 - **macOS**
+
     ```bash
     MyMac:~ test$ python3.5 -V
     Python 3.5.4
@@ -153,10 +155,13 @@ Visit [here](https://caffe2.ai/docs/getting-started.html) to build from source c
 To install MXNet, run the following command in a terminal:
 
 - With GPU
+
     ```bash
     pip3.5 install mxnet-cu80==0.12.0
     ```
+
 - Without GPU
+
     ```bash
     pip3.5 install mxnet==0.12.0
     ```

docs/azure/vs-azure-tools-configure-roles-for-cloud-service.md

@@ -250,7 +250,7 @@ The following code shows an example of how to write a text file to local storage
 
 To view the file created by the code in the previous section, follow these steps:
 
-1.  In the Windows notification area, right-click the Azure icon, and, from the context menu, select **Show Compute Emulator UI**.
+1. In the Windows notification area, right-click the Azure icon, and, from the context menu, select **Show Compute Emulator UI**.
 
     ![Show Azure compute emulator](./media/vs-azure-tools-configure-roles-for-cloud-service/show-compute-emulator.png)
 

docs/azure/vs-azure-tools-diagnostics-for-cloud-services-and-virtual-machines.md

@@ -148,6 +148,7 @@ If you're using Azure SDK 2.5 and want to specify a custom data source, you can
    <DataSource name="CustomDataSource!*" />
 </WindowsEventLog>
 ```
+
 ### Performance counters
 Performance counter information can help you locate system bottlenecks and fine-tune system and application performance. For more information, see [Create and use performance counters in an Azure application](https://msdn.microsoft.com/library/azure/hh411542.aspx). To capture performance counters, select the **Enable transfer of Performance Counters** check box. To increase or decrease the interval between the transfer of event logs to your storage account, change the **Transfer Period (min)** value. Select the check boxes for the performance counters that you want to track.
 

docs/azure/vs-azure-tools-optimizing-azure-code-in-visual-studio.md

@@ -209,6 +209,7 @@ while (true)
    }
 }
 ```
+
 ## Consider using asynchronous Service Bus methods
 ### ID
 AP2003

docs/azure/vs-azure-tools-resource-groups-ci.md

@@ -166,6 +166,7 @@ The following procedures walk you through the steps necessary to configure conti
      ```
      -_artifactsLocation $(artifactsLocation) -_artifactsLocationSasToken (ConvertTo-SecureString -String "$(artifactsLocationSasToken)" -AsPlainText -Force)
      ```
+
      ![Configure Azure Resource Group Deployment Task](media/vs-azure-tools-resource-groups-ci-in-vsts/walkthrough18.png)
 7. After you’ve added all the required items, save the build pipeline and choose **Queue new build** at the top.
 

docs/code-quality/C26404.md

@@ -18,6 +18,7 @@ Once owner pointer releases or transfers its resource, it gets into an "invalid"
 Deleting such a pointer may lead to immediate memory corruption due to double delete, or to an access violation when the deleted resource is accessed from another owner pointer.
 
 ## Example 1: Deleting an owner after transferring its value
+
 ```cpp
 gsl::owner<State*> validState = nullptr;
 gsl::owner<State*> state = ReadState();
@@ -27,6 +28,7 @@ if (!IsValid(state))
 ```
 
 ## Example 2: Deleting an uninitialized owner
+
 ```cpp
 gsl::owner<Message*> message;
 if (popLast)

docs/code-quality/C26405.md

@@ -17,6 +17,7 @@ ms.workload:
 If an owner pointer already points to a valid memory buffer, it must not be assigned to another value without releasing its current resource first. Such assignment may lead to a resource leak even if the resource address is copied into some raw pointer (because raw pointers shouldn’t release resources).
 
 ## Example 1: Overwriting an owner in a loop
+
 ```cpp
 gsl::owner<Shape*> shape = nullptr;
 while (shape = NextShape()) // C26405

docs/code-quality/C26406.md

@@ -17,6 +17,7 @@ ms.workload:
 Owners are initialized from allocations or from other owners. Assigning a value from a raw pointer to an owner pointer is not allowed. Raw pointers don’t guarantee ownership transfer; there is still may be an original owner which holds the resource and will attempt to release it. Note that assigning a value from owner to a raw pointer is fine; raw pointers are valid clients to access resources, but not to manage them.
 
 ## Example 1:  Using address of object
+
 ```cpp
 gsl::owner<Socket*> socket = defaultSocket ? &defaultSocket : new Socket(); // C26406
 ```

docs/code-quality/C26407.md

@@ -23,26 +23,31 @@ To avoid unnecessary use of pointers we try to detect common patterns of local a
 - The pattern is detected only for local variables, so we don’t warn on cases where an allocation is assigned to, say, a global variable and then deleted in the same function.
 
 ## Example 1: Unnecessary object allocation on heap
+
 ```cpp
 auto tracer = new Tracer();
 ScanObjects(tracer);
 delete tracer;  // C26407
 ```
 
 ## Example 2: Unnecessary object allocation on heap (fixed with local object)
+
 ```cpp
 Tracer tracer;  // OK
 ScanObjects(&tracer);
 ```
 
 ## Example 3: Unnecessary buffer allocation on heap
+
 ```cpp
 auto value = new char[maxValueSize];
 if (ReadSetting(name, value, maxValueSize))
     CheckValue(value);
 delete[] value; // C26407
 ```
+
 ## Example 4: Unnecessary buffer allocation on the heap (fixed with container)
+
 ```cpp
 auto value = std::vector<char>(maxValueSize); // OK
 if (ReadSetting(name, value.data(), maxValueSize))

docs/code-quality/C26410.md

@@ -21,6 +21,7 @@ Generally, references to const unique pointer are meaningless. They can safely b
 - Template code may produce a lot of noise. Keep in mind that templates can be instantiated with various type parameters with different levels of indirection, including references. Some warnings may not be obvious and fixes may require some rework of templates (for example, explicit removal of reference indirection). If template code is intentionally generic, the warning can be suppressed.
 
 ## Example 1: Unnecessary reference
+
 ```cpp
 std::vector<std::unique_ptr<Tree>> roots = GetRoots();
 std::for_each(

docs/code-quality/C26416.md

@@ -22,10 +22,10 @@ R.34: Take a shared_ptr\<widget> parameter to express that a function is part ow
 Passing a shared pointer by rvalue reference is usually unnecessary. Unless it is an implementation of move semantics for a shared pointer type itself, shared pointer objects can be safely passed by value. Using rvalue reference may be also an indication that unique pointer is more appropriate since it clearly transfers unique ownership from caller to callee.
 
 ## Remarks
--  This check recognizes std::shared_pointer and user-defined types which are likely to behave like shared pointers. The following traits are expected for user-defined shared pointers:
--  overloaded dereference or member access operators (public and non-deleted);
--  copy constructor or copy assignment operator (public and non-deleted);
--  public destructor which is neither deleted nor defaulted. Empty destructors are still counted as user-defined.
+- This check recognizes std::shared_pointer and user-defined types which are likely to behave like shared pointers. The following traits are expected for user-defined shared pointers:
+- overloaded dereference or member access operators (public and non-deleted);
+- copy constructor or copy assignment operator (public and non-deleted);
+- public destructor which is neither deleted nor defaulted. Empty destructors are still counted as user-defined.
 
 ## Example
 questionable constructor optimization

docs/code-quality/C26417.md

@@ -22,13 +22,13 @@ R.35: Take a shared_ptr\<widget>& parameter to express that a function might res
 Passing shared pointers by reference may be useful in scenarios where callee code updates target of the smart pointer object and its caller expects to see such update. Using a reference solely to reduce costs of passing a shared pointer is questionable. If callee code only accesses target object and never manages its lifetime, it is safer to pass raw pointer or reference, rather than to expose resource management details.
 
 ## Remarks
--  This check recognizes std::shared_pointer and user-defined types which are likely to behave like shared pointers. The following traits are expected for user-defined shared pointers:
--  overloaded dereference or member access operators (public and non-deleted);
--  copy constructor or copy assignment operator (public and non-deleted);
--  public destructor which is neither deleted nor defaulted. Empty destructors are still counted as user-defined.
--  The action of resetting or reassigning is interpreted in a more generic way:
--  any call to a non-constant function on a shared pointer can potentially reset the pointer;
--  any call to a function which accepts a reference to a non-constant shared pointer can potentially reset or reassign that pointer.
+- This check recognizes std::shared_pointer and user-defined types which are likely to behave like shared pointers. The following traits are expected for user-defined shared pointers:
+- overloaded dereference or member access operators (public and non-deleted);
+- copy constructor or copy assignment operator (public and non-deleted);
+- public destructor which is neither deleted nor defaulted. Empty destructors are still counted as user-defined.
+- The action of resetting or reassigning is interpreted in a more generic way:
+- any call to a non-constant function on a shared pointer can potentially reset the pointer;
+- any call to a function which accepts a reference to a non-constant shared pointer can potentially reset or reassign that pointer.
 
 ## Example
 unnecessary interface complication

docs/code-quality/C26418.md

@@ -22,10 +22,10 @@ R.36: Take a const shared_ptr\<widget>& parameter to express that it might retai
 If shared pointer parameter is passed by value or reference to a constant object it is expected that function will take control of its target object’s lifetime without affecting of the caller. The code should either copy or move the shared pointer parameter to another shared pointer object or pass it further to other code by invoking functions which accept shared pointers. If this is not the case, then plain pointer or reference may be feasible.
 
 ## Remarks
--  This check recognizes std::shared_pointer and user-defined types which are likely to behave like shared pointers. The following traits are expected for user-defined shared pointers:
--  overloaded dereference or member access operators (public and non-deleted);
--  copy constructor or copy assignment operator (public and non-deleted);
--  public destructor which is neither deleted nor defaulted. Empty destructors are still counted as user-defined.
+- This check recognizes std::shared_pointer and user-defined types which are likely to behave like shared pointers. The following traits are expected for user-defined shared pointers:
+- overloaded dereference or member access operators (public and non-deleted);
+- copy constructor or copy assignment operator (public and non-deleted);
+- public destructor which is neither deleted nor defaulted. Empty destructors are still counted as user-defined.
 
 ## Example
 unnecessary interface complication

docs/code-quality/C26432.md

@@ -23,11 +23,11 @@ Special operations like constructors are assumed to alter behavior of types so t
 
 ## Remarks
 - This check implements "the rule of five" which treats the following operations as special:
-  -  copy constructors;
-  -  move constructors;
-  -  copy assignment operators;
-  -  move assignment operators;
-  -  destructors;
-  -  The rule doesn’t check if operations are defined in the same way, i.e. it is okay to mix deleted and defaulted operations with explicitly defined, but they all must be specified somehow if any of them appears.
-  -  Access levels are not important and can also be mixed.
-  -  The warning flags the first non-static function definition of a type, once per type.
+  - copy constructors;
+  - move constructors;
+  - copy assignment operators;
+  - move assignment operators;
+  - destructors;
+  - The rule doesn’t check if operations are defined in the same way, i.e. it is okay to mix deleted and defaulted operations with explicitly defined, but they all must be specified somehow if any of them appears.
+  - Access levels are not important and can also be mixed.
+  - The warning flags the first non-static function definition of a type, once per type.

docs/code-quality/C26436.md

@@ -23,4 +23,4 @@ If a class defines a virtual function it becomes polymorphic, which implies that
 
 ## Remarks
 - The warning shows up on the first virtual function definition of a type (it can be a virtual destructor if it is not public), once per type.
-  -  Since definition can be placed separately from declaration, it may not always have any of the virtual specifiers. But the warning is still valid – it checks the actual ‘virtuality’ of a function.
+  - Since definition can be placed separately from declaration, it may not always have any of the virtual specifiers. But the warning is still valid – it checks the actual ‘virtuality’ of a function.

docs/code-quality/C26439.md

@@ -23,10 +23,10 @@ Some kinds of operations should never cause exceptions. Their implementations sh
 
 ## Remarks
 - Special kinds of operations are the following:
-  -  destructors;
-  -  default constructors;
-  -  move constructors and move assignment operators;
-  -  standard functions with move semantics: std::move and std::swap.
-  -  Non-standard and outdated specifiers like throw() or declspec(nothrow) are not equivalent to ‘noexcept’.
-  -  Explicit specifiers noexcept(false) and noexcept(true) are respected appropriately.
-  -  The warning may still appear for operations that are marked as constexpr. This may change in future releases.
+  - destructors;
+  - default constructors;
+  - move constructors and move assignment operators;
+  - standard functions with move semantics: std::move and std::swap.
+  - Non-standard and outdated specifiers like throw() or declspec(nothrow) are not equivalent to ‘noexcept’.
+  - Explicit specifiers noexcept(false) and noexcept(true) are respected appropriately.
+  - The warning may still appear for operations that are marked as constexpr. This may change in future releases.

docs/code-quality/C26440.md

@@ -23,10 +23,10 @@ If code is not supposed to cause any exceptions, it should be marked as such by
 
 ## Remarks
 - A function is considered non-throwing if:
-  -  it has no explicit throw statements;
-  -  function calls in its body, if any, invoke only functions that unlikely to throw: constexpr or functions marked with any exception specification which entails non-throwing behavior (this includes some non-standard specifications).
-  -  Non-standard and outdated specifiers like throw() or declspec(nothrow) are not equivalent to ‘noexcept’.
-  -  Explicit specifiers noexcept(false) and noexcept(true) are respected appropriately.
-  -  Functions marked as constexpr are not supposed to cause exceptions and are not analyzed.
-  -  The rule also applies to lambda expressions.
-  -  The logic doesn’t consider recursive calls as potentially non-throwing. This may change in the future.
+  - it has no explicit throw statements;
+  - function calls in its body, if any, invoke only functions that unlikely to throw: constexpr or functions marked with any exception specification which entails non-throwing behavior (this includes some non-standard specifications).
+  - Non-standard and outdated specifiers like throw() or declspec(nothrow) are not equivalent to ‘noexcept’.
+  - Explicit specifiers noexcept(false) and noexcept(true) are respected appropriately.
+  - Functions marked as constexpr are not supposed to cause exceptions and are not analyzed.
+  - The rule also applies to lambda expressions.
+  - The logic doesn’t consider recursive calls as potentially non-throwing. This may change in the future.

docs/code-quality/C26450.md

@@ -30,6 +30,7 @@ int multiply()
     return c;
 }
 ```
+
  To correct this warning, use the following code.
 
 ```cpp
@@ -53,6 +54,7 @@ int add()
     return c;
 }
 ```
+
  To correct this warning, use the following code:
 
 ```cpp
@@ -64,6 +66,7 @@ long long add()
     return c;
 }
 ```
+
 ## Example 3
 
 ```cpp
@@ -75,6 +78,7 @@ int subtract()
     return c;
 }
 ```
+
  To correct this warning, use the following code.
 
 ```cpp

docs/code-quality/C26451.md

@@ -30,6 +30,7 @@ void leftshift(int i)
   // code
 }
 ```
+
 To correct this warning, use the following code:
 
 ```cpp
@@ -41,6 +42,7 @@ void leftshift(int i)
   // code
 }
 ```
+
 ## Example 2
 
 ```cpp

docs/code-quality/C26452.md

@@ -26,6 +26,7 @@ unsigned __int64 combine(unsigned lo, unsigned hi)
   return (hi << 32) | lo; // C26252 here
 }
 ```
+
  To correct this warning, use the following code:
 
 ```cpp

docs/code-quality/C26454.md

@@ -26,6 +26,7 @@ unsigned int negativeunsigned()
     return x;
 }
 ```
+
  To correct this warning, use the following code:
 
 ```cpp