Merge branch 'master' into kraigb-python-tutorials

Author: kraigb

.openpublishing.redirection.json

@@ -2167,6 +2167,36 @@
           "source_path": "docs/ide/quickstart-visual-basic-winforms.md",
           "redirect_url": "/visualstudio/ide/create-a-visual-basic-winform-in-visual-studio",
           "redirect_document_id": false
+        },
+        {
+          "source_path": "subscriptions/buy-vs-subscriptions.md",
+          "redirect_url": "http://www.visualstudio.com/vs/pricing/",
+          "redirect_document_id": false
+        },
+        {
+          "source_path": "subscriptions/compare-subscriptions.md",
+          "redirect_url": "http://www.visualstudio.com/vs/pricing/",
+          "redirect_document_id": false
+        },
+        {
+          "source_path": "subscriptions/vscloud-first-purchase.md",
+          "redirect_url": "/visualstudio/subscriptions/vscloud-overview",
+          "redirect_document_id": false
+        },
+        {
+          "source_path": "subscriptions/vscloud-renewals.md",
+          "redirect_url": "/visualstudio/subscriptions/vscloud-overview",
+          "redirect_document_id": false
+        },
+        {
+          "source_path": "subscriptions/vscloud-buy-more.md",
+          "redirect_url": "/visualstudio/subscriptions/vscloud-overview",
+          "redirect_document_id": false
+        },
+        {
+          "source_path": "subscriptions/vscloud-cancel.md",
+          "redirect_url": "/visualstudio/subscriptions/vscloud-overview",
+          "redirect_document_id": false
         }
     ]
 }

docs/TOC.md

@@ -1,6 +1,5 @@
 # [Visual Studio Documentation](ide/index.md)
 # [Overview](ide/visual-studio-ide.md)
-## [What's New](ide/whats-new-in-visual-studio.md)
 # Installation
 ## [Install Visual Studio](install/install-visual-studio.md)
 ## [Sign in to Visual Studio](ide/signing-in-to-visual-studio.md)
@@ -449,6 +448,17 @@
 ### [Install Dotfuscator CE](ide/dotfuscator/install.md)
 ### [Upgrade Dotfuscator CE](ide/dotfuscator/upgrades.md)
 # Resources
+## [What's New](ide/whats-new-in-visual-studio.md)
+## Release notes & system requirements
+### [Current release notes](/visualstudio/releasenotes/vs2017-relnotes?context=visualstudio/default)
+### [Preview release notes](/visualstudio/releasenotes/vs2017-preview-relnotes?context=visualstudio/default)
+### [Release notes history](/visualstudio/releasenotes/vs2017-relnotes-history?context=visualstudio/default)
+### [Release rhythm](/visualstudio/productinfo/vs2017-release-rhythm?context=visualstudio/default)
+### [System requirements](/visualstudio/productinfo/vs2017-system-requirements-vs?context=visualstudio/default)
+### [Platform compatibility](/visualstudio/productinfo/vs2017-compatibility-vs?context=visualstudio/default)
+### [Licensing](https://www.visualstudio.com/license-terms/)
+### [Distributable code](/visualstudio/productinfo/2017-redistribution-vs?context=visualstudio/default)
+### [Support lifecycle and servicing](/visualstudio/productinfo/vs-servicing-vs?context=visualstudio/default)
 ## [How to Report a Problem with Visual Studio](ide/how-to-report-a-problem-with-visual-studio-2017.md)
 ## [Resources for Troubleshooting IDE Errors](ide/reference/resources-for-troubleshooting-integrated-development-environment-errors.md)
 ## [Talk to Us](ide/talk-to-us.md)

docs/code-quality/TOC.md

@@ -349,15 +349,39 @@
 ### [C26441](C26441.md)
 ### [C26443](c26443.md)
 ### [C26444](c26444.md)
+### [C26445](c26445.md)
+### [C26446](c26446.md)
+### [C26447](c26447.md)
+### [C26448](c26448.md)
+### [C26449](c26449.md)
 ### [C26450](C26450.md)
 ### [C26451](C26451.md)
 ### [C26452](C26452.md)
 ### [C26453](C26453.md)
 ### [C26454](C26454.md)
+### [C26460](C26460.md)
+### [C26461](C26461.md)
+### [C26462](C26462.md)
+### [C26463](C26463.md)
+### [C26464](C26464.md)
+### [C26465](C26465.md)
+### [C26466](C26466.md)
+### [C26471](C26471.md)
 ### [C26472](C26472.md)
 ### [C26473](C26473.md)
 ### [C26474](C26474.md)
 ### [C26475](C26475.md)
+### [C26482](C26482.md)
+### [C26483](C26483.md)
+### [C26490](C26490.md)
+### [C26491](C26491.md)
+### [C26492](C26492.md)
+### [C26493](C26493.md)
+### [C26494](C26494.md)
+### [C26495](C26495.md)
+### [C26496](C26496.md)
+### [C26497](C26497.md)
+### [C26498](C26498.md)
 ## [Code Analysis for C/C++ Warnings](code-analysis-for-c-cpp-warnings.md)
 ### [C1250](c1250.md)
 ### [C1251](c1251.md)

docs/code-quality/c26445.md

@@ -0,0 +1,46 @@
+---
+title: "C26445 | Microsoft Docs"
+ms.custom: ""
+ms.date: "03/22/2018"
+ms.reviewer: ""
+ms.suite: ""
+ms.technology: 
+  - "vs-ide-code-analysis"
+ms.tgt_pltfrm: ""
+ms.topic: "article"
+f1_keywords: 
+  - "C26445"
+helpviewer_keywords: 
+  - "C26445"
+author: mikeblome
+ms.author: mblome
+manager: ghogen
+ms.workload: 
+  - "multiple"
+---
+# C26445 NO_SPAN_REF
+A reference to `gsl::span` or `std::string_view` may be an indication of a lifetime issue.
+C++ Core Guidelines: [GSL.view: Views](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslview-views)
+
+The intention of this rule is to catch subtle lifetime issues that may occur in code which has been migrated from standard containers to new span and view types. Such types can be considered as “references to buffers.” Using a reference to a span or view creates an additional layer of indirection. Such indirection is often unnecessary and can be confusing for maintainers. In addition, spans are cheap to copy and can be returned by value from function calls. Obviously, such call results should never be referenced.
+
+## Remarks
+
+- The rule detects references to gsl::span<>, gsl::basic_string_span<>, and std::basic_string_view<> (including aliases to instantiations).
+- Currently warnings are emitted only on declarations and return statements. This may be extended in future to also flag function parameters.
+- The implementation of this rule is very lightweight doesn’t attempt to trace actual lifetimes. Using of references may still make sense in some scenarios. In such cases, false positives can safely be suppressed.
+
+## Example: Reference to a temporary
+
+```cpp
+// Old API - uses string reference to avoid data copy.
+const std::string& get_working_directory() noexcept;
+
+// New API – after migration to C++17 it uses string view.
+std::string_view get_working_directory() noexcept;
+
+// ...
+// Client code which places an explicit reference in a declaration with auto specifier.
+const auto &wd = get_working_directory(); // C26445 after API update.
+```
+

docs/code-quality/c26446.md

@@ -0,0 +1,40 @@
+---
+title: "C26446 | Microsoft Docs"
+ms.custom: ""
+ms.date: "03/22/2018"
+ms.reviewer: ""
+ms.suite: ""
+ms.technology: 
+  - "vs-ide-code-analysis"
+ms.tgt_pltfrm: ""
+ms.topic: "article"
+f1_keywords: 
+  - "C26446"
+helpviewer_keywords: 
+  - "C26446"
+author: mikeblome
+ms.author: mblome
+manager: ghogen
+ms.workload: 
+  - "multiple"
+---
+# C26446 USE_GSL_AT
+
+Prefer to use `gsl::at()` instead of unchecked subscript operator.
+
+C++ Core Guidelines: [Bounds.4: Don't use standard-library functions and types that are not bounds-checked](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#probounds-bounds-safety-profile).
+
+The Bounds profile of the C++ Core Guidelines tries to eliminate unsafe manipulations of memory by avoiding the use of raw pointers and unchecked operations. One way to perform uniform range-checked access to buffers is to use the `gsl::at()` utility from the Guidelines Support Library. It is also a good practice to rely on standard implementations of `at()` available in STL containers.
+
+This rule helps to find places where potentially unchecked access is performed via calls to operator\[](). In most cases such calls can be easily replaced by `gsl::at()`.
+
+
+- Access to arrays with known size is flagged when non-constant index is used in a subscript operator. Constant indices are handled by [C26483 STATIC_INDEX_OUT_OF_RANGE](c26483.md).
+- The logic to warn on overloaded operator[] calls is more complex:
+  - If index is non-integral, the call is ignored. This also handles indexing in standard maps since parameters in such operators are passed by reference.
+  - If the operator is marked as non-throwing (by using **noexcept**, **throw()**, or **__declspec(nothrow)**), the call is flagged. It is assumed that if the subscript operator never throws exceptions it either doesn’t perform range checks or these checks are obscure.
+  - If the operator is not marked as non-throwing, it may be flagged if it comes from an STL container that also defines a conventional `at()` member function (such functions are detected by simple name matching).
+  - The rule doesn’t warn on calls to standard `at()` methods. These methods are safe and replacing them with `gsl::at()` would not bring much value.
+- Indexing into `std::basic_string_view<>` is not safe, so a warning is issued. The standard string view can be replaced by `gsl::basic_string_span<>`, which is always bounds-checked.
+- The implementation doesn’t consider range checks that user code may have somewhere in loops or branches. Accuracy here is traded for performance. In general, explicit range checks can often be replaced with more reliable iterators or more concise enhanced for-loops.
+

docs/code-quality/c26447.md

@@ -0,0 +1,34 @@
+---
+title: "C26447 | Microsoft Docs"
+ms.custom: ""
+ms.date: "03/22/2018"
+ms.reviewer: ""
+ms.suite: ""
+ms.technology: 
+  - "vs-ide-code-analysis"
+ms.tgt_pltfrm: ""
+ms.topic: "article"
+f1_keywords: 
+  - "C26447"
+helpviewer_keywords: 
+  - "C26447"
+author: mikeblome
+ms.author: mblome
+manager: ghogen
+ms.workload: 
+  - "multiple"
+---
+# C26447 DONT_THROW_IN_NOEXCEPT
+
+The function is declared **noexcept** but calls a function that may throw exceptions.
+
+C++ Core Guidelines: 
+[F.6: If your function may not throw, declare it noexcept](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#f6-if-your-function-may-not-throw-declare-it-noexcept).
+
+This rule amends another rule, [C26440 DECLARE_NOEXCEPT](c26440.md), which tries to find functions that are good candidates to be marked as **noexcept**. In this case, the idea is that once some function is marked as **noexcept**, it must keep its contract by not invoking other code that may throw exceptions.
+
+- The Microsoft C++ compiler already handles straightforward violations like **throw** statements in the function body (see [C4297](/cpp/error-messages/compiler-warnings/compiler-warning-level-1-c4297)).
+- The rule focuses only on function calls. It flags targets that are not **constexpr** and that can potentially throw exceptions; in other words they are not marked explicitly as non-throwing by using **noexcept**, **__declspec(nothrow)**, **throw()**.
+- The compiler-generated target functions are skipped to reduce noise since exception specifications are not always provided by the compiler.
+- The checker also skips special kinds of target functions that are expected to be implemented as **noexcept**; this rule is enforced by [C26439 SPECIAL_NOEXCEPT](c26439.md).
+

docs/code-quality/c26448.md

@@ -0,0 +1,85 @@
+---
+title: "C26448 | Microsoft Docs"
+ms.custom: ""
+ms.date: "03/22/2018"
+ms.reviewer: ""
+ms.suite: ""
+ms.technology: 
+  - "vs-ide-code-analysis"
+ms.tgt_pltfrm: ""
+ms.topic: "article"
+f1_keywords: 
+  - "C26448"
+helpviewer_keywords: 
+  - "C26448"
+author: mikeblome
+ms.author: mblome
+manager: ghogen
+ms.workload: 
+  - "multiple"
+---
+# C26448 USE_GSL_FINALLY 
+
+Consider using `gsl::finally` if final action is intended.
+
+C++ Core Guidelines: [GSL.util: Utilities](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#SS-utilities)
+
+The Guidelines Support Library provides a convenient utility to implement the *final action* concept. Since the C++ language doesn't support **try-finally** constructs, it became common to implement custom cleanup types that would invoke arbitrary actions on destruction. The `gsl::finally` utility is implemented in this way and provides a more uniform way to perform final actions across a code base.
+
+There are also cases where final actions are performed in an old-fashioned C-style way by using **goto** statements (which is generally discouraged by [C26438 NO_GOTO](c26438.md)). It is hard to detect the exact intention in code that heavily uses **goto**, but some heuristics can help to find better candidates for cleanup.
+
+## Remarks
+
+- This rule is very lightweight and uses label names to guess about opportunities to use final action objects.
+- Label names that can raise a warning contain words like "end", "final", "clean", and so on.
+- Warnings appear at the **goto** statements. You may see verbose output on some occasions, but this may help in prioritizing code depending on its complexity.
+- This rule always goes in pair with [C26438 NO_GOTO](c26438.md). Depending on the priorities, one of these can be disabled.
+
+## Example: Cleanup with multiple goto statements
+
+```cpp
+void poll(connection_info info)
+{
+    connection c = {};
+    if (!c.open(info))
+        return;
+
+    while (c.wait())
+    {
+        connection::header h{};
+        connection::signature s{};
+        if (!c.read_header(h))
+            goto end;               // C26448 and C26438
+        if (!c.read_signature(s))
+            goto end;               // C26448 and C26438
+        // ...
+    }
+
+end:
+    c.close();
+}
+```
+
+## Example: Cleanup with multiple goto statements replaced by gsl::finally
+
+```cpp
+void poll(connection_info info)
+{
+    connection c = {};
+    if (!c.open(info))
+        return;
+
+    auto end = gsl::finally([&c] { c.close(); });
+    while (c.wait())
+    {
+        connection::header h{};
+        connection::signature s{};
+        if (!c.read_header(h))
+            return;
+        if (!c.read_signature(s))
+            return;
+        // ...
+    }
+}
+```
+

docs/code-quality/c26449.md

@@ -0,0 +1,58 @@
+---
+title: "C26449 | Microsoft Docs"
+ms.custom: ""
+ms.date: "03/22/2018"
+ms.reviewer: ""
+ms.suite: ""
+ms.technology: 
+  - "vs-ide-code-analysis"
+ms.tgt_pltfrm: ""
+ms.topic: "article"
+f1_keywords: 
+  - "C26449"
+helpviewer_keywords: 
+  - "C26449"
+author: mikeblome
+ms.author: mblome
+manager: ghogen
+ms.workload: 
+  - "multiple"
+---
+# C26449 NO_SPAN_FROM_TEMPORARY
+
+`gsl::span` or `std::string_view` created from a temporary will be invalid when the temporary is invalidated.
+
+C++ Core Guidelines: [GSL.view: Views](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslview-views).
+
+Spans and views are convenient and lightweight types that allow to reference memory buffers. But they must be used carefully: while their interface looks similar to standard containers, their behavior is more like the behavior of pointers and references. They do not own data and must never be constructed from temporary buffers. This check focuses on cases where source data is temporary, while span or view is not. There is another check which handles slightly different scenario involving span references: [C26445 NO_SPAN_REF](c26445.md). Both rules can help to avoid subtle but dangerous mistakes made when legacy code gets modernized and adopts spans or views.
+
+## Remarks
+
+- This rule warns on places where constructors get invoked for spans or views and the source data buffer belongs to a temporary object created in the same statement. This includes:
+  - implicit conversions in return statements;
+  - implicit conversions in ternary operators;
+  - explicit conversions in `static_cast` expressions;
+  - function calls that return containers by value.
+- Temporaries created for function call arguments are not flagged. It is safe to pass spans from such temporaries if target functions don’t retain data pointers in external variables.
+- If spans or views are themselves temporaries, the rule skips them.
+- Data tracking in the checker has certain limitations; therefore complex scenarios involving multiple or obscure reassignments may not be handled.
+
+## Example: Subtle difference in result types
+
+```cpp
+// Returns a predefined collection. Keeps data alive.
+gsl::span<const sequence_item> get_seed_sequence() noexcept;
+
+// Returns a generated collection. Doesn’t own new data.
+const std::vector<sequence_item> get_next_sequence(gsl::span<const sequence_item>);
+
+void run_batch()
+{
+    auto sequence = get_seed_sequence();
+    while (send(sequence))
+    {
+        sequence = get_next_sequence(sequence); // C26449
+        // ...
+    }
+}
+```

docs/code-quality/c26460.md

@@ -0,0 +1,23 @@
+---
+title: "C26460 | Microsoft Docs"
+ms.custom: ""
+ms.date: "03/22/2018"
+ms.reviewer: ""
+ms.suite: ""
+ms.technology: 
+  - "vs-ide-code-analysis"
+ms.tgt_pltfrm: ""
+ms.topic: "article"
+f1_keywords: 
+  - "C26460"
+helpviewer_keywords: 
+  - "C26460"
+author: mikeblome
+ms.author: mblome
+manager: ghogen
+ms.workload: 
+  - "multiple"
+---
+# C26460 USE_CONST_REFERENCE_ARGUMENTS
+
+  The reference argument '%argument%' for function '%function%' can be marked as `const`. See [C++ Core Guidelines con.3](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Rconst-ref).