Merge pull request #3630 from microsoft/0_23_1_release

0 23 1 release

.github/ISSUE_TEMPLATE/language-service.md

@@ -34,6 +34,6 @@ about: 'Issues pertaining to IntelliSense, autocomplete, code editing, etc. '
 
 **Additional context**
 <!--
-*Call Stacks: For bugs like crashes, deadlocks, infinite loops, etc. that we are not able to repro and for which the call stack may be useful, please attach a debugger and/or create a dmp and provide the call stacks. Starting with 0.17.3, Windows binaries have symbols available in VS Code by setting your "symbolSearchPath" to "http://msdl.microsoft.com/download/symbols".*
-Add any other context about the problem here including log messages in your Output window ("C_Cpp.loggingLevel": "Debug" in settings.json).
+* Call Stacks: For bugs like crashes, deadlocks, infinite loops, etc. that we are not able to repro and for which the call stack may be useful, please attach a debugger and/or create a dmp and provide the call stacks. Windows binaries have symbols available in VS Code by setting your "symbolSearchPath" to "https://msdl.microsoft.com/download/symbols".
+* Add any other context about the problem here including log messages in your Output window ("C_Cpp.loggingLevel": "Debug" in settings.json).
 -->

.gitignore

@@ -0,0 +1,7 @@
+# ignore cache files for sample projects
+.vscode/ipch
+browse*.db*
+*.obj
+*.pdb
+*.exe
+*.ilk

.travis.yml

@@ -1,43 +0,0 @@
-language: node_js
-
-node_js:
-- "8"
-
-before_install:
-  # Do not modify. Required for GUI based tests: See https://docs.travis-ci.com/user/gui-and-headless-browsers/#Using-xvfb-to-Run-Tests-That-Require-a-GUI
-  - if [ $TRAVIS_OS_NAME == "linux" ]; then
-      export CXX="g++-4.9" CC="gcc-4.9" DISPLAY=:99.0;
-      sh -e /etc/init.d/xvfb start;
-      sleep 3;
-    fi
-
-addons:
-  apt:
-    sources:
-      - ubuntu-toolchain-r-test
-      - sourceline: 'deb https://packages.microsoft.com/repos/microsoft-ubuntu-trusty-prod trusty main'
-        key_url: 'https://packages.microsoft.com/keys/microsoft.asc'
-    packages:
-      - gdb
-      - g++-4.9
-
-
-script:
-  # Download debugAdapters from an existing extension version. See TravisCI settings to set CPPTOOL_VERSION
-  - mkdir -p ~/.vscode/extensions/ms-vscode.cpptools-$CPPTOOL_VERSION
-  - wget https://github.com/Microsoft/vscode-cpptools/releases/download/$CPPTOOL_VERSION/cpptools.vsix -O ~/cpptools.vsix
-  - unzip ~/cpptools.vsix "extension/debugAdapters/*" -d ~/.
-  - mv ~/extension/debugAdapters ~/.vscode/extensions/ms-vscode.cpptools-$CPPTOOL_VERSION/debugAdapters
-  # Build and then run tests
-  - cd Extension
-  - npm install
-  - npm run compile
-  - npm run tslint
-  # pr-check needs to run before test. test modifies package.json.
-  - npm run pr-check
-  - npm run unitTests
-  # TODO: Merge tests into one group due to Gulp 4.0
-  - npm run integrationTests
-  # Dump integrationTest.log output
-  - find ~ -name "integrationTests.log" -type f -exec cat {} \;
-  

Code Samples/BoxConsoleSample/Objects/box.h

@@ -0,0 +1,19 @@
+#ifndef BOX_H
+#define BOX_H
+
+/**
+ * Definition of a box object with three dimensions.
+ */
+struct box
+{
+    int length;
+    int width;
+    int height;
+
+    int volume()
+    {
+        return length * width * height;
+    }
+};
+
+#endif

Code Samples/BoxConsoleSample/README.md

@@ -0,0 +1,24 @@
+# Box Sample
+This sample is a simple C++ program that computes and outputs the volume of a box.
+
+We use this example in our blog posts to illustrate new extension features.
+
+## Build and Debug Active File
+Available as of March 2019, "Build and Debug Active File" automatically configures the build tasks and kicks off a build and debug session. There are
+three ways to get started with this feature.
+
+### Command
+While editing a file in your workspace folder, you can open the command palette and select the `C/C++: Build and Debug Active File` command.
+This option will generate a tasks.json file for you, build your active source file, and then launch the debugger.
+
+![Open command palette and select Build and Debug Active File](build_debug_command.png)
+
+### Context Menu
+While editing a file in a workspace folder, you can right click in the editor field and select the "Build and Debug Active File" context menu option.
+This option will generate a tasks.json file for you, build your active source file, and then launch the debugger.
+
+![Right click and select Build and Debug Active File](build_debug_context_menu.png)
+
+### F5
+Another way to begin building and debugging your active file is to execute the command by pressing <kbd>F5</kbd>. This method will configure
+both a tasks.json and launch.json file for you, build your active source file, and then launch the debugger. 

Code Samples/BoxConsoleSample/box_sample.cpp

@@ -0,0 +1,16 @@
+#include <iostream>
+#include "Objects/box.h"
+
+using namespace std;
+
+/**
+ * Calculate and print the volume of a box.
+ */
+int main()
+{
+    box package{ 10, 10, 10 };
+    cout << "Package length: " << package.length << endl;
+    cout << "Package width:  " << package.width << endl;
+    cout << "Package height: " << package.height << endl;
+    cout << "Package volume: " << package.volume() << endl;
+}

Code Samples/SampleClangProject/.gitignore

@@ -1,2 +0,0 @@
-main.exe
-main.exe.dSYM

Code Samples/SampleClangProject/.vscode/launch.json

@@ -1,17 +0,0 @@
-{
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "name": "(lldb) Launch",
-            "type": "cppdbg",
-            "request": "launch",
-            "program": "${workspaceRoot}/main.exe", // this is executable to launch the debugger with
-            "args": ["YourNameHere"],
-            "stopAtEntry": true, // if true then stop at the main entry (function)
-            "cwd": "${workspaceRoot}",
-            "environment": [],
-            "externalConsole": true,
-            "MIMode": "lldb"
-        }
-    ]
-}

Code Samples/SampleClangProject/.vscode/tasks.json

@@ -1,19 +0,0 @@
-{
-    // See https://go.microsoft.com/fwlink/?LinkId=733558
-    // for the documentation about the tasks.json format
-    "version": "2.0.0",
-    "tasks": [
-        {
-            "label": "clang++",
-            "command": "clang++ --debug -o main.exe main.cpp",
-                // "--debug" enables debugging symbols
-                // "-o main.exe" specifies the output executable
-                // "main.cpp" is the source file to compile
-            "type": "shell",
-            "group": {
-                "kind": "build",
-                "isDefault": true
-            }
-        }
-    ]
-}

Code Samples/SampleClangProject/README.md

@@ -1,10 +0,0 @@
-# README
-This is a sample debuggable C++ project. It uses the vendor provided version of clang installed. `tasks.json` and `launch.json` have been edited to demonstrate how to create a configuration for a C++ project that builds with clang.
-
-There's a sample build task in `.vscode/tasks.json`; you can also see the build configurations by using the menu option `Configure` -> `Configure Tasks` or by clicking the gear icon in the Debug Panel.
-
-To run a build, use the menu option `Tasks` -> `Run Build Task...`.
-
-There's a sample debug configuration in `.vscode/launch.json`; you can also see the configuration by using the menu option `Debug` -> `Open Configurations`.
-
-To debug the build, use the menu option `Debug` -> `Start Debugging`. The executable will launch and stop in the main function.

Code Samples/SampleClangProject/main.cpp

@@ -1,17 +0,0 @@
-#include <iostream>
-#include <string>
-
-using namespace std;
-
-void greet(const string& person) {
-    cout << "Hello, " << person << "!" << endl;
-}
-
-int main(int argc, char** argv) {
-    if(argc >= 2) {
-        greet(argv[1]);
-    } else {
-        cerr << "insufficient args, usage: " << argv[0] << " personNameHere" << endl;
-    }
-    return 0;
-}

Documentation/Building the Extension.md

@@ -3,7 +3,8 @@
 These steps will allow you to debug the TypeScript code that is part of the Microsoft CppTools extension for Visual Studio Code.
 
 Prerequisite steps:
-  * Clone [this](https://github.com/Microsoft/vscode-cpptools) repository.
+  * Clone the release branch of [this](https://github.com/Microsoft/vscode-cpptools) repository.
+      * git clone -b release https://github.com/Microsoft/vscode-cpptools
   * Install [npm](https://nodejs.org).
   * From a command line, run the following commands from the **Extension** folder in the root of the repository:
       * `npm install` will install the dependencies needed to build the extension.

Documentation/Debugger/How To Debug MIEngine.md

@@ -15,12 +15,13 @@ You can open the solution file **MIDebugEngine.sln** located under **src** and c
 * Microsoft.MIDebugEngine.dll
 * vscode\OpenDebugAD7.exe
 * vscode\Microsoft.DebugEngineHost.dll
+* vscode\Microsoft.VisualStudio.Shared.VSCodeDebugProtocol.dll
 
 The symbol files are as follows:
 
 **On Windows** 
 * Microsoft.MICore.pdb
-* Microsoft.MIDebugEngine.dll
+* Microsoft.MIDebugEngine.pdb
 * vscode\OpenDebugAD7.pdb
 * vscode\Microsoft.DebugEngineHost.pdb
 
@@ -51,11 +52,13 @@ This will cause the debugger to look like it has hung once you start debugging,
 
 ### Debugging MIEngine running on Linux or Mac OS X
 
+#### With MonoDevelop
+
 On Linux and Mac OS X, we use `mono` as our framework. You can download Xamarin Studio v5.10.1.6 and remotely attach to your Mac or Linux box to debug there.
 
-#### Install Prerequisites
-1. Install [GTK](http://www.mono-project.com/download/)
-2. Install [Xamarin Studio v5.10.1.6](http://download.xamarin.com/studio/Windows/XamarinStudio-5.10.1.6-0.msi)
+##### Install Prerequisites
+1. Install [GTK](http://www.mono-project.com/download/).
+2. Install [Xamarin Studio v5.10.1.6](http://download.xamarin.com/studio/Windows/XamarinStudio-5.10.1.6-0.msi).
 
 Remote attach functionality behind a flag.  You can run it like this:
 ```PowerShell
@@ -64,26 +67,60 @@ set MONODEVELOP_SDB_TEST=1
 MonoDevelop.exe
 ```
 
-#### Create an empty project for attaching (one-time setup)
+##### Create an empty project for attaching (one-time setup)
 
-1. Launch MonoDevelop
-2. File -> New Solution
-3. Misc/Generic Project
-4. Name project and hit "Create"
-5. Right-click the project node (blue square) and do "Options"
+1. Launch MonoDevelop.
+2. File -> New Solution.
+3. Misc/Generic Project.
+4. Name project and hit "Create".
+5. Right-click the project node (blue square) and do "Options".
 6. Under Run -> Custom Commands, select "Execute" in the lower dropdown and choose a command (I use `c:\windows\notepad.exe` - it doesn't matter what the command is, but MonoDevelop requires it to exist before it'll light up the Run menu).
 
-#### Configure the extension to enable remote debugging
+##### Configure the extension to enable remote debugging
 
 Open the **~/.vscode/extensions/ms-vscode.cpptools-\<version\>/debugAdapters/OpenDebugAD7** file with a text editor and locate and uncomment the line at the bottom. When you start debugging, it will now hang until the remote debugger is attached from Xamarin Studio. 
 
-#### Attach the remote debugger
+##### Attach the remote debugger
 
-In MonoDevelop: Run -> Run With -> Custom Command Mono Soft Debugger
-Fill in the IP and port of the Linux/Mac OS X machine and hit "Connect" to start debugging
+In MonoDevelop: Run -> Run With -> Custom Command Mono Soft Debugger.
+Fill in the IP and port of the Linux/Mac OS X machine and hit "Connect" to start debugging.
 
 After you've done this once, you can hit the MonoDevelop "Play" button or <kbd>F5</kbd> to bring up the connect dialog again.
 
-Note: If you are debugging to CentOS, you will need to make an exception in the firewall
+#### With VS Code + Mono Debug
+
+##### Install Prerequisites
+1. Install [VS Code](https://code.visualstudio.com/Download).
+2. Install Mono Debug extension for VS Code.
+
+##### Create an empty project (one-time setup)
+1. Open to a new folder and create `.vscode/launch.json`.
+2. Create the following configuration in launch.json.
+```
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Attach to Mono",
+            "request": "attach",
+            "type": "mono",
+            "address": "<INSERT_MACHINE_IP_ADDRESS_HERE>",
+            "port": 1234
+        }
+    ]
+}
+```
+
+##### Configure the extension to enable remote debugging
+
+Open the **~/.vscode/extensions/ms-vscode.cpptools-\<version\>/debugAdapters/OpenDebugAD7** file with a text editor and locate and uncomment the line at the bottom. When you start debugging, it will now hang until the remote debugger is attached from VS Code. 
+
+##### Attach the remote debugger
+
+Select the `Attach to Mono` configuration and hit F5.
+
+#### Additional Notes
+
+Note: If you are debugging to CentOS, you will need to make an exception in the firewall.
 * `sudo firewall-cmd --zone=public --add-port=1234/tcp --permanent`
 * `sudo firewall-cmd --reload`

Documentation/FAQs.md

@@ -2,6 +2,8 @@
 
 ## Table of Contents
 * Setup: [Debugging Setup](#debugging-setup)
+* Setup: [What is the .vscode/ipch folder?](#what-is-the-vscodeipch-folder)
+* Setup: [How do I disable the IntelliSense cache (ipch)?](#how-do-i-disable-the-intellisense-cache-ipch)
 * Debugger: [Why is debugging not working?](#why-is-debugging-not-working)
 * Build: [How to enable debug symbols](#how-to-enable-debug-symbols)
 * Logging: [How to enable logging](#how-to-enable-logging)
@@ -15,6 +17,24 @@ The file **launch.json** will now be open for editing with a new configuration.
 
 See the [**Documentation/Debugger**](https://github.com/Microsoft/vscode-cpptools/tree/master/Documentation/Debugger) folder in this repository for more in-depth documentation on how to configure the debugger.
 
+## What is the .vscode/ipch folder?
+
+The language server caches information about included header files to improve the performance of IntelliSense. When you edit C/C++ files in your workspace folder, the language server will store cache files in the `.vscode/ipch` folder by default. VS Code per-workspace storage folders were not selected for the following reasons:
+* The workspace storage location provided by VS Code is somewhat obscure and we had reservations about writing GB's worth of files in this location where users may not see them or know where to find them.
+* Parity with Visual Studio. This is how Visual Studio works and they receive little to no feedback/complaints on the location.
+
+With this in mind we knew that we wouldn't be able to please everyone, so we provided settings to allow you to customize this the way that works best for your situation.  We also figured that putting the files in the workspace folder would bring the issue to your attention quickly so that you can take action if you don't like the default behavior.
+
+#### `"C_Cpp.intelliSenseCachePath": <string>`
+This setting allows you to set workspace or global overrides for the cache path. For example, if you want to share a single cache location for all workspace folders, you just open the VS Code settings, and add a "User" setting for "IntelliSense Cache Path".
+
+#### `"C_Cpp.intelliSenseCacheSize": <number>`
+This setting allows you to set a limit on the amount of caching the extension does. This is an approximation, but the extension will make a best effort to keep the cache size as close to the limit you set as possible. If you are sharing the cache location across workspaces as explained above, you can still increase/decrease the limit, but you should make sure that you add a "User" setting for "IntelliSense Cache Size".
+
+## How do I disable the IntelliSense cache (ipch)?
+
+If you do not want to use the IntelliSense caching feature to improve the performance of IntelliSense, you can disable the feature by setting the "IntelliSense Cache Size" setting to 0. (or `"C_Cpp.intelliSenseCacheSize": 0"` in the JSON settings editor)
+
 ## Why is debugging not working?
 
 ### My breakpoints aren't being hit
@@ -23,7 +43,7 @@ When you start debugging, if it is showing that your breakpoints aren't bound (s
 
 ### Debugging starts but all the lines in my stack trace are grey
 
-If your debugger is showing a grey stacktrace or won't stop at a breakpoint,or the symbols in the call stack are grey then your executable was compiled without [debug symbols](#how-to-enable-debug-symbols).
+If your debugger is showing a grey stacktrace or won't stop at a breakpoint, or the symbols in the call stack are grey then your executable was compiled without [debug symbols](#how-to-enable-debug-symbols).
 
 ## How to enable debug symbols?
 

Documentation/LanguageServer/FAQ.md

@@ -31,7 +31,7 @@ If you want IntelliSense to operate on your files even when all #include directi
 The most common reason for this is missing include paths and defines. The easiest way to fix this on each platform is as follows:
 
 **Linux/Mac**
-* Set `"intelliSenseMode": "clang-x64"` and `"compilerPath"` in **c_cpp_properties.json** to the path to your compiler.
+* Set `"intelliSenseMode": "clang-x64"` or `"intelliSenseMode": "gcc-x64"` and `"compilerPath"` in **c_cpp_properties.json** to the path to your compiler.
 
 **Windows**
 * If you are using a Microsoft compiler from Visual Studio, set `"intelliSenseMode": "msvc-x64"`, but don't add the `"compilerPath"` property to **c_cpp_properties.json**.

Documentation/LanguageServer/MinGW.md

@@ -20,6 +20,12 @@ When you set the `compilerPath` property and change `intelliSenseMode` to `clang
 }
 ```
 
+Replace "gcc.exe" with whatever compiler you're using, e.g. "g++.exe", "clang-5.0.exe", etc. -- just make sure the file is a valid Windows executable (not a 0 size symlink).
+
+For Cygwin, set the `compilerPath` to the appropriate Cygwin path, e.g. "C:/cygwin64/bin/g++.exe".
+
+If it seems like the `compilerPath` is not getting used, you can debug the issue via [enabling logging](Enabling%20logging.md).
+
 ## Extension version 0.16.1 and earlier:
 
 If you have an older version of the C/C++ extension installed, use [these instructions](Archive/MinGW.md) instead.

Extension/.gitignore

@@ -3,6 +3,7 @@ node_modules
 
 # ignore compliled typescript
 out
+dist
 
 # ignore downloaded extension files and folders
 server
@@ -18,4 +19,3 @@ install.lock
 
 # ignore vscode test
 .vscode-test/
-browse*db*

Extension/.vscode/launch.json

@@ -13,9 +13,9 @@
 			"stopOnEntry": false,
 			"sourceMaps": true,
 			"outFiles": [
-				"${workspaceFolder}/out/**/*.js"
+				"${workspaceFolder}/dist/**/*.js"
 			],
-			"preLaunchTask": "compile",
+			"preLaunchTask": "Compile Dev",
 		},
 		{
 			"name": "Launch Tests",
@@ -31,7 +31,7 @@
 			"outFiles": [
 				"${workspaceFolder}/out/test/**/*.js"
 			],
-			"preLaunchTask": "compile"
+			"preLaunchTask": "TypeScript Compile"
 		},
 		{
 			"name": "Node Attach",
@@ -47,13 +47,14 @@
 			"args": [
 				"${workspaceFolder}/test/integrationTests/testAssets/SimpleCppProject",
 				"--extensionDevelopmentPath=${workspaceFolder}",
-				"--extensionTestsPath=${workspaceFolder}/out/test/integrationTests"
+				"--extensionTestsPath=${workspaceFolder}/out/test/integrationTests/languageServer"
 			],
 			"stopOnEntry": false,
 			"sourceMaps": true,
 			"outFiles": [
 				"${workspaceFolder}/out/test/**/*.js"
-			]
+			],
+			"preLaunchTask": "Pretest"
 		},
 	]
 }

Extension/.vscode/tasks.json

@@ -5,7 +5,6 @@
     "tasks": [
         {
             "label": "TypeScript Compile",
-            "identifier": "compile",
             "group": {
                 "kind": "build",
                 "isDefault": true
@@ -29,7 +28,6 @@
         },
         {
             "label": "TypeScript Lint",
-            "identifier": "tslint",
             "group": "build",
             "isBackground": false,
             "type": "shell",
@@ -53,8 +51,38 @@
                 ]
             },
             "dependsOn": [
-                "compile"
+                "TypeScript Compile"
             ]
+        },
+        {
+            "label": "Compile Dev",
+            "group": "build",
+            "isBackground": false,
+            "type": "shell",
+            "command": "npm",
+            "args": [
+                "run",
+                "compileDev"
+            ],
+            "dependsOn": [
+                "TypeScript Compile"
+            ],
+            "problemMatcher": "$tsc-watch"
+        },
+        {
+            "label": "Pretest",
+            "group": "build",
+            "isBackground": false,
+            "type": "shell",
+            "command": "npm",
+            "args": [
+                "run",
+                "pretest"
+            ],
+            "dependsOn": [
+                "TypeScript Compile"
+            ],
+            "problemMatcher": "$tsc-watch"
         }
     ]
 }

Extension/.vscodeignore

@@ -1,15 +1,36 @@
-obj/**
+
+# ignore vscode settings for extension development
 .vscode/**
-typings/**
-out/test/**
+
+# ignore binaries
+obj/**
+
+# ignore source files
+tools/**
+notices/**
 test/**
 src/**
-**/*.map
-.gitignore
+
+# ignore .js files that are webpacked or only used for development
+out/src/**
+out/tools/**
+
+# ignore ts files in ui
+ui/*.ts
+
+# ignore Azure-Pipelines files
+jobs/**
+
+# ignore development files
 tsconfig.json
+test.tsconfig.json
+tslint.json
+webpack.config.js
+tscCompileList.txt
+gulpfile.js
+.gitattributes
+.gitignore
 CMakeLists.txt
 debugAdapters/install.lock*
-out/src/Debugger/copyScript.js
-tools/**
-out/tools/**
-notices/**
+typings/**
+**/*.map

Extension/CHANGELOG.md

@@ -1,5 +1,157 @@
 # C/C++ for Visual Studio Code Change Log
 
+## Version 0.23.1: May 13, 2019
+### Bug Fixes
+* Fix `launch.json` creation when `intelliSenseEngine` is `"Disabled"`. [#3583](https://github.com/microsoft/vscode-cpptools/issues/3583)
+* Fix C/C++ commands not working if the language service isn't activated. [#3615](https://github.com/microsoft/vscode-cpptools/issues/3615)
+* Fix missing extension `"Details"` page. [#3621](https://github.com/microsoft/vscode-cpptools/issues/3621)
+* Fix some random crashes related to IntelliSense inactive region processing.
+
+## Version 0.23.0: May 6, 2019
+### New Features
+* Add a configuration UI editor to edit IntelliSense settings defined in the underlying `c_cpp_properties.json` file. [PR #3479](https://github.com/Microsoft/vscode-cpptools/pull/3479), [PR #3487](https://github.com/Microsoft/vscode-cpptools/pull/3487), [PR #3519](https://github.com/Microsoft/vscode-cpptools/pull/3519), [#3524](https://github.com/Microsoft/vscode-cpptools/issues/3524), [PR #3563](https://github.com/Microsoft/vscode-cpptools/pull/3563), [#3526](https://github.com/Microsoft/vscode-cpptools/issues/3526)
+  * Add a new command `C/C++: Edit configurations (UI)` to open the UI editor.
+  * Replace the `C/C++: Edit configurations...` command with `C/C++: Edit configurations (JSON)` to open `c_cpp_properties.json`.
+  * The default whether to open the UI editor or JSON file is based on the `workbench.settings.editor` setting.
+* Add command `C/C++: Log Diagnostics` to log language service diagnostics. [PR #3489](https://github.com/Microsoft/vscode-cpptools/pull/3489)
+* Add support for `.env` files for `cppvsdbg`. [#3490](https://github.com/Microsoft/vscode-cpptools/issues/3490)
+
+### Other Changes
+* Enable flag `/permissive-` as an argument to `compilerPath` with `cl.exe`. [#1589](https://github.com/Microsoft/vscode-cpptools/issues/1589), [#3446](https://github.com/Microsoft/vscode-cpptools/issues/3446)
+* Configuration squiggles for `c_cpp_properties.json` now validates if the setting values of `compilerPath` and `intelliSenseMode` match on Windows. [#2983](https://github.com/Microsoft/vscode-cpptools/issues/2983)
+* Enable `-fms-extensions` to be used as an argument to `compilerPath` on Linux/Mac. [#3063](https://github.com/Microsoft/vscode-cpptools/issues/3063)
+* Change the default value of `C_Cpp.intelliSenseEngineFallback` setting to `Disabled`. [#3165](https://github.com/Microsoft/vscode-cpptools/issues/3165)
+* Add squiggle when `compilerPath` uses spaces and arguments without `"`. [#3357](https://github.com/Microsoft/vscode-cpptools/issues/3357)
+* Change the `Disabled` value for `C_Cpp.errorSquiggles` to stop showing missing header squiggles. [#3361](https://github.com/Microsoft/vscode-cpptools/issues/3361)
+* Add `enableConfigurationSquiggles` setting to allow squiggles to be disabled for `c_cpp_properties.json`. [#3403](https://github.com/Microsoft/vscode-cpptools/issues/3403)
+* Switch to using the `installExtension` command for offline/insider vsix installing (to reduce install failures). [#3408](https://github.com/Microsoft/vscode-cpptools/issues/3408)
+* Add a better example to the description of `C_Cpp.clang_format_style` and `C_Cpp.clang_format_fallback_style`. [#3419](https://github.com/Microsoft/vscode-cpptools/issues/3419)
+* Add a new (default) value of `EnabledIfIncludesResolve` to `C_Cpp.errorSquiggles`, which only shows error squiggles if include headers are successfully resolved. [PR #3421](https://github.com/Microsoft/vscode-cpptools/pull/3421)
+* Disable debug heap by default with cppvsdbg. [#3484](https://github.com/Microsoft/vscode-cpptools/issues/3484)
+  * Reported by Djoulihen (@Djoulihen)
+* Enable configuration squiggles for paths delimited by semicolons. [PR #3517](https://github.com/Microsoft/vscode-cpptools/pull/3517)
+* Don't show release notes if the extension has never been installed before. [#3533](https://github.com/Microsoft/vscode-cpptools/issues/3533)
+* Remove IntelliSense fallback code actions.
+
+### Bug Fixes
+* Fix browsing for functions with BOOST_FOREACH. [#953](https://github.com/Microsoft/vscode-cpptools/issues/953)
+* Fix code action sometimes not appearing over a squiggled identifier. [#1436](https://github.com/microsoft/vscode-cpptools/issues/1436)
+* Work around issue with VS Code not treating `.C` files as C++ files [Microsoft/vscode#59369](https://github.com/Microsoft/vscode/issues/59369) -- `.C` files become associated by name in `files.associations`. [#2558](https://github.com/Microsoft/vscode-cpptools/issues/2558)
+* Fix various IntelliSense parsing bugs. [#2824](https://github.com/Microsoft/vscode-cpptools/issues/2824), [#3110](https://github.com/Microsoft/vscode-cpptools/issues/3110), [#3168](https://github.com/Microsoft/vscode-cpptools/issues/3168)
+* Preserve newlines in documentation comments. [#2937](https://github.com/Microsoft/vscode-cpptools/issues/2937)
+* Fix documentation comments above multi-line templates (and some other issues). [#3162](https://github.com/Microsoft/vscode-cpptools/issues/3162)
+* Fix "Extension causes high cpu load" due to module loading. [#3213](https://github.com/Microsoft/vscode-cpptools/issues/3213)
+* Fix auto-removal of compiler-provided paths in `includePath` when they end with a directory separator on Windows. [#3245](https://github.com/Microsoft/vscode-cpptools/issues/3245)
+* Fix duplicate compiler build tasks appearing when `compilerPath` has arguments. [PR #3360](https://github.com/Microsoft/vscode-cpptools/pull/3360)
+* Fix environment variables not resolving with `C_Cpp.intelliSenseCachePath`. [#3367](https://github.com/Microsoft/vscode-cpptools/issues/3367)
+* Fix the formatting of snippets text. [#3376](https://github.com/Microsoft/vscode-cpptools/issues/3376)
+* Fix the default `AccessModifierOffset` used when formatting. [#3376](https://github.com/Microsoft/vscode-cpptools/issues/3376)
+* Fix null reference during initialization when using custom configuration providers. [PR #3377](https://github.com/Microsoft/vscode-cpptools/pull/3377)
+* Fix symbol parsing when `__MINGW_ATTRIB_*` is used. [#3390](https://github.com/Microsoft/vscode-cpptools/issues/3390)
+* Fix `compile_commands.json` configuration prompt being disabled per user instead of per folder. [PR #3399](https://github.com/Microsoft/vscode-cpptools/pull/3399)
+* Fix `.cmd` and `.bat` files not working for `compilerPath` on Windows. [#3428](https://github.com/Microsoft/vscode-cpptools/issues/3428)
+* Fix `compilerPath` with arguments that are surrounded by quotes. [#3428](https://github.com/Microsoft/vscode-cpptools/issues/3428)
+* Fix documentation comments interpreting special characters as markdown. [#3441](https://github.com/Microsoft/vscode-cpptools/issues/3441)
+* Fix hover using the configuration of the active document instead of the hovered document. [#3452](https://github.com/Microsoft/vscode-cpptools/issues/3452)
+* Fix `c_cpp_properties.json` squiggles when the configuration name has regex characters. [PR #3478](https://github.com/Microsoft/vscode-cpptools/pull/3478)
+* Use the `editor.tabSize` setting instead of `2` when creating build tasks. [PR #3486](https://github.com/Microsoft/vscode-cpptools/pull/3486)
+* Fix some potential crashes on hover. [#3509](https://github.com/Microsoft/vscode-cpptools/issues/3509)
+* Fix for `NullReferenceException` occurring when `"args"` is not specified in `launch.json`. [#3532](https://github.com/Microsoft/vscode-cpptools/issues/3532)
+* Fix `Go to Definition` giving no results when IntelliSense doesn't find the symbol. [#3549](https://github.com/Microsoft/vscode-cpptools/issues/3549)
+* Fix configuration squiggles with trailing backslashes. [PR #3573](https://github.com/Microsoft/vscode-cpptools/pull/3573)
+* Fix `includePath` code actions, configuration prompts, and the `C/C++: Change configuration provider...` command. [PR #3576](https://github.com/Microsoft/vscode-cpptools/pull/3576)
+* Fix randomly occurring crash (that could occur when opening files while IntelliSense squiggles are pending).
+* Fix crash on hover (that could occur when document comments have blank lines).
+* Fix icon of parameters in completion results.
+
+## Version 0.22.1: March 21, 2019
+* Fix `tasks.json` with single-line comments being overwritten when `Build and Debug Active File` is used. [#3327](https://github.com/Microsoft/vscode-cpptools/issues/3327)
+* Fix an invalid `compilerPath` property getting added to `tasks.json` after doing `Configure Task` with a C/C++ compiler.
+* Add IntelliSense caching for macOS 10.13 or later (0.22.0 only supported Windows and Linux).
+
+## Version 0.22.0: March 19, 2019
+### Major Changes
+* Add warning squiggles for invalid properties and paths in `c_cpp_properties.json`. [#2799](https://github.com/Microsoft/vscode-cpptools/issues/2799), [PR #3283](https://github.com/Microsoft/vscode-cpptools/pull/3283)
+* Add C/C++ compiler build tasks for compiling the active source file, with support for `F5` debugging and the `Build and Debug Active File` context menu command. [PR #3118](https://github.com/Microsoft/vscode-cpptools/pull/3118), [PR #3244](https://github.com/Microsoft/vscode-cpptools/pull/3244)
+* Add AutoPCH support to reduce IntelliSense parsing time, with `C_Cpp.intelliSenseCachePath` and `C_Cpp.intelliSenseCacheSize` settings. It isn't enabled for Mac yet. [PR #3184](https://github.com/Microsoft/vscode-cpptools/pull/3184)
+
+### Minor Changes
+* Fix IntelliSense not working on Windows when the username has a space in it and file `C:\Users\<firstname>` exists. [#1377](https://github.com/Microsoft/vscode-cpptools/issues/1377), [#2114](https://github.com/Microsoft/vscode-cpptools/issues/2114), [#2176](https://github.com/Microsoft/vscode-cpptools/issues/2176), [#3052](https://github.com/Microsoft/vscode-cpptools/issues/3052), [#3139](https://github.com/Microsoft/vscode-cpptools/issues/3139)
+* Enable `${command:cpptools.activeConfigName}` in tasks. [#1524](https://github.com/Microsoft/vscode-cpptools/issues/1524)
+* Fix bugs with squiggles and IntelliSense updating after edits. [#1779](https://github.com/Microsoft/vscode-cpptools/issues/1779), [#3124](https://github.com/Microsoft/vscode-cpptools/issues/3124), [#3260](https://github.com/Microsoft/vscode-cpptools/issues/3260)
+* Fix formatting (and other non-IntelliSense operations) being blocked by IntelliSense processing. [#1928](https://github.com/Microsoft/vscode-cpptools/issues/1928)
+* Fix completion when the start of an identifier matches a keyword. [#1986](https://github.com/Microsoft/vscode-cpptools/issues/1986)
+* Fix auto-removal of compiler-provided paths in `includePath`. [#2177](https://github.com/Microsoft/vscode-cpptools/issues/2177)
+* Fix crash on Windows when 8.3 filenames are used. [#2453](https://github.com/Microsoft/vscode-cpptools/issues/2453), [#3104](https://github.com/Microsoft/vscode-cpptools/issues/3104)
+* Add support for `Scope::Member` scoped symbol searches. [#2484](https://github.com/Microsoft/vscode-cpptools/issues/2484)
+* Fix signature help active parameter selection when parameter names are missing or subsets of each other. [#2952](https://github.com/Microsoft/vscode-cpptools/issues/2952)
+* Fix `--enable-pretty-printing` with `gdb` when complex objects are used as keys in maps. [#3024](https://github.com/Microsoft/vscode-cpptools/issues/3024)
+* Fix IntelliSense-based `Go to Definition` for `noexcept` methods. [#3060](https://github.com/Microsoft/vscode-cpptools/issues/3060)
+* Render macro hover expansions as C/C++. [#3075](https://github.com/Microsoft/vscode-cpptools/issues/3075)
+* Enable completion after `struct` when manually invoked. [#3080](https://github.com/Microsoft/vscode-cpptools/issues/3080)
+* Add `C_Cpp.suggestSnippets` setting to disable language server snippets. [#3083](https://github.com/Microsoft/vscode-cpptools/issues/3083)
+* Show a prompt for changing `C_Cpp.updateChannel` to `Insiders`. [#3089](https://github.com/Microsoft/vscode-cpptools/issues/3089)
+  * lh123 (@lh123) [PR #3221](https://github.com/Microsoft/vscode-cpptools/pull/3221)
+* Fix `compilerPath` not getting priority over the `compile_commands.json` compiler. [#3102](https://github.com/Microsoft/vscode-cpptools/issues/3102)
+* Fix Linux `compile_commands.json` compiler querying with relative paths. [#3112](https://github.com/Microsoft/vscode-cpptools/issues/3112)
+* Allow `*` in `includePath` to apply to `browse.path` when `browse.path` is not specified. [#3121](https://github.com/Microsoft/vscode-cpptools/issues/3121)
+  * Tucker Kern (@mill1000) [PR #3122](https://github.com/Microsoft/vscode-cpptools/pull/3122)
+* Disable `(` and `<` completion commit characters. [#3127](https://github.com/Microsoft/vscode-cpptools/issues/3127)
+* Add Chinese translations for command titles. [PR #3128](https://github.com/Microsoft/vscode-cpptools/pull/3128)
+* Fix remote process picker bug. [#2585](https://github.com/Microsoft/vscode-cpptools/issues/2585), [#3150](https://github.com/Microsoft/vscode-cpptools/issues/3150)
+* Fix command not found and empty `c_cpp_properties.json` if activation is too slow. [#3160](https://github.com/Microsoft/vscode-cpptools/issues/3160), [#3176](https://github.com/Microsoft/vscode-cpptools/issues/3176)
+* Fix `cppvsdbg` debugger showing `"An unspecified error has occurred."` for structured binding variables. [#3197](https://github.com/Microsoft/vscode-cpptools/issues/3197)
+* Fix bugs with the Insider reload prompt appearing when it shouldn't. [#3206](https://github.com/Microsoft/vscode-cpptools/issues/3206)
+* Fix variable expansion (e.g. `${env.HOME}`) not working when `${default}` is used in `c_cpp_properties.json`. [#3309](https://github.com/Microsoft/vscode-cpptools/issues/3309)
+* Fix other unreported IntelliSense engine bugs.
+
+## Version 0.21.0: January 23, 2019
+### New Features
+* Add documentation comments for hover, completion, and signature help. [#399](https://github.com/Microsoft/vscode-cpptools/issues/399)
+* Add completion committing for methods after `(`. [#1184](https://github.com/Microsoft/vscode-cpptools/issues/1184)
+* Add macro expansions to hover. [#1734](https://github.com/Microsoft/vscode-cpptools/issues/1734)
+* Add support for `__int128_t` and `__uint128_t` types. [#1815](https://github.com/Microsoft/vscode-cpptools/issues/1815)
+* Add Italian translations for command titles.
+  * Julien Russo (@Dotpys) [PR #2663](https://github.com/Microsoft/vscode-cpptools/pull/2663)
+* Add icons for operators, structs/unions, enum values, template arguments, and macros. [#2849](https://github.com/Microsoft/vscode-cpptools/issues/2849)
+* Change `#include` completion to show individual folders instead of the entire paths, fixing previous performance problems. [#2836](https://github.com/Microsoft/vscode-cpptools/issues/2836)
+* Add text `(declaration)`, `(typedef)`, `(type alias)`, and `(union)` to symbols. [#2851](https://github.com/Microsoft/vscode-cpptools/issues/2851)
+* Add a refresh button to the `Attach to Process` picker. [#2885](https://github.com/Microsoft/vscode-cpptools/issues/2885)
+  * Matt Bise (@mbise1993) [PR #2895](https://github.com/Microsoft/vscode-cpptools/pull/2895)
+* Add completion committing for templates after `<`. [#2953](https://github.com/Microsoft/vscode-cpptools/issues/2953)
+
+### Bug Fixes
+* Add the Microsoft digital signature to Windows binaries to avoid getting incorrectly flagged by virus scanners. [#1103](https://github.com/Microsoft/vscode-cpptools/issues/1103), [#2970](https://github.com/Microsoft/vscode-cpptools/issues/2970)
+* Fix bugs when UTF-8 characters > 1 byte are used. [#1504](https://github.com/Microsoft/vscode-cpptools/issues/1504), [#1525](https://github.com/Microsoft/vscode-cpptools/issues/1525), [#2034](https://github.com/Microsoft/vscode-cpptools/issues/2034), [#2082](https://github.com/Microsoft/vscode-cpptools/issues/2082), [#2883](https://github.com/Microsoft/vscode-cpptools/issues/2883)
+* Fix some IntelliSense process crashes. [#1785](https://github.com/Microsoft/vscode-cpptools/issues/1785), [#2913](https://github.com/Microsoft/vscode-cpptools/issues/2913)
+* Fix several incorrect IntelliSense error squiggles. [#1942](https://github.com/Microsoft/vscode-cpptools/issues/1942), [#2422](https://github.com/Microsoft/vscode-cpptools/issues/2422), [#2474](https://github.com/Microsoft/vscode-cpptools/issues/2474), [#2478](https://github.com/Microsoft/vscode-cpptools/issues/2478), [#2597](https://github.com/Microsoft/vscode-cpptools/issues/2597), [#2763](https://github.com/Microsoft/vscode-cpptools/issues/2763)
+* Fix some main process crashes. [#2505](https://github.com/Microsoft/vscode-cpptools/issues/2505), [#2768](https://github.com/Microsoft/vscode-cpptools/issues/2768)
+* Fix incorrect IntelliSense error with Mac clang 10.0 libraries. [#2608](https://github.com/Microsoft/vscode-cpptools/issues/2608)
+* Fix completion not working in template specializations. [#2620](https://github.com/Microsoft/vscode-cpptools/issues/2620)
+* Fix incorrect completions after Enter is used after struct, class, etc. [#2734](https://github.com/Microsoft/vscode-cpptools/issues/2734)
+* Fix memory "leak" when parsing a large workspace. [#2737](https://github.com/Microsoft/vscode-cpptools/issues/2737)
+* Fix IntelliSense-based `Go to Definition` with overloads that return a template with a default param (e.g. vector) [#2736](https://github.com/Microsoft/vscode-cpptools/issues/2736)
+* Fix `Go to Definition` when `__catch()`, `_NO_EXCEPT_DEBUG`, or `_LIBCPP_BEGIN_NAMESPACE_STD` is used. [#2761](https://github.com/Microsoft/vscode-cpptools/issues/2761), [#2766](https://github.com/Microsoft/vscode-cpptools/issues/2766)
+* Fix `Go to Definition` when `method(void)` is used. [#2802](https://github.com/Microsoft/vscode-cpptools/issues/2802)
+* Fix error `"TypeError: Cannot read property 'map' of undefined at asCompletionResult"`. [#2807](https://github.com/Microsoft/vscode-cpptools/issues/2807)
+* Fix quotes around defines not supported for custom configuration providers. [#2820](https://github.com/Microsoft/vscode-cpptools/issues/2820)
+* Fix PowerShell bug on Win7. [#2822](https://github.com/Microsoft/vscode-cpptools/issues/2822)
+* Fix Tag Parser completion details missing keywords (i.e. `using`, `class`, `#define`, etc.). [#2850](https://github.com/Microsoft/vscode-cpptools/issues/2850)
+* Fix problem with empty recursive include paths. [#2855](https://github.com/Microsoft/vscode-cpptools/issues/2855)
+* Fix `NullReferenceException` on debugger launch with VS Code Insiders. [#2858](https://github.com/Microsoft/vscode-cpptools/issues/2858), [PR Microsoft/MIEngine#810](https://github.com/Microsoft/MIEngine/pull/810)
+* Fix IntelliSense errors with template argument deduction. [#2907](https://github.com/Microsoft/vscode-cpptools/issues/2907), [#2912](https://github.com/Microsoft/vscode-cpptools/issues/2912)
+* Retry Insider VSIX downloading with `http.proxySupport` `"off"`. [#2927](https://github.com/Microsoft/vscode-cpptools/issues/2927)
+* Fix snippet completions being offered when they shouldn't be. [#2942](https://github.com/Microsoft/vscode-cpptools/issues/2942)
+* Set the `editor.wordBasedSuggestions` to `false` by default to prevent incorrect completions. [#2943](https://github.com/Microsoft/vscode-cpptools/issues/2943)
+* Fix IntelliSense-based `Go to Definition` for functions with function pointer parameters. [#2981](https://github.com/Microsoft/vscode-cpptools/issues/2981)
+* Fix `<` incorrectly triggering completions. [#2985](https://github.com/Microsoft/vscode-cpptools/issues/2985)
+* Fix recursive includes not adding paths used by `forcedInclude` files. [#2986](https://github.com/Microsoft/vscode-cpptools/issues/2986)
+* Fix crash when `//` is used in a recursive `includePath`. [#2987](https://github.com/Microsoft/vscode-cpptools/issues/2987)
+* Fix compiler in `compile_commands.json` not taking precedence over the `Cpp.default.compilerPath`. [#2793](https://github.com/Microsoft/vscode-cpptools/issues/2793)
+* Fix `#include` completion not working for symlinks. [#2843](https://github.com/Microsoft/vscode-cpptools/issues/2843)
+* Fix IntelliSense-based `Go to Definition` for `const` methods. [#3014](https://github.com/Microsoft/vscode-cpptools/issues/3014)
+* Support `C_Cpp.updateChannel` for VS Code Exploration builds.
+
 ## Version 0.20.1: October 31, 2018
 * Fix IntelliSense-based `Go to Declaration` when there's only a definition in a TU. [#2743](https://github.com/Microsoft/vscode-cpptools/issues/2743)
 * Fix `#include` completion for standalone header files. [#2744](https://github.com/Microsoft/vscode-cpptools/issues/2744)
@@ -45,7 +197,7 @@
   * Gabriel Arjones (@g-arjones) [PR #2495](https://github.com/Microsoft/vscode-cpptools/pull/2495), [PR #2503](https://github.com/Microsoft/vscode-cpptools/pull/2503)
 * Fix bug with variable resolution. [#2532](https://github.com/Microsoft/vscode-cpptools/issues/2532)
 * Fix off-by-one bug with hover and `Go to Definition`. [#2535](https://github.com/Microsoft/vscode-cpptools/issues/2535)
-* Fix for [Microsoft/vscode#54213](https://github.com/Microsoft/vscode/issues/54213)
+* Fix [Microsoft/vscode#54213](https://github.com/Microsoft/vscode/issues/54213)
 
 ## Version 0.18.1: August 17, 2018
 * Fix 0.18.0 regression causing non-MinGW compilers to use `-fms-extensions` on Windows. [#2424](https://github.com/Microsoft/vscode-cpptools/issues/2424), [#2425](https://github.com/Microsoft/vscode-cpptools/issues/2425)
@@ -109,10 +261,11 @@
 * Fix variables not resolving in `macFrameworkPath`. [#2234](https://github.com/Microsoft/vscode-cpptools/issues/2234)
 * Fix `Go to Definition` not working for macros followed by `.` or `->`. [#2245](https://github.com/Microsoft/vscode-cpptools/issues/2245)
 * Fix `#include` autocomplete with Mac framework headers. [#2251](https://github.com/Microsoft/vscode-cpptools/issues/2251)
-* Fix for debugging to support empty arguments for debuggee. [#2258](https://github.com/Microsoft/vscode-cpptools/issues/2258)
+* Fix debugging to support empty arguments for debuggee. [#2258](https://github.com/Microsoft/vscode-cpptools/issues/2258)
 * Fix `Go to Definition` bug (missing symbols outside the workspace). [#2281](https://github.com/Microsoft/vscode-cpptools/issues/2281)
+* Fix incorrect hover in enum definitions. [#2286](https://github.com/Microsoft/vscode-cpptools/issues/2286)
 * Add a setting to silence configuration provider warnings. [#2292](https://github.com/Microsoft/vscode-cpptools/issues/2292)
-* Fix for debugging async Visual C++ causing debugger to hang.
+* Fix debugging async Visual C++ causing debugger to hang.
 * Fix `main` snippet.
 
 ## Version 0.17.6: July 2, 2018
@@ -147,9 +300,9 @@
 * On Windows, `compilerPath` now populates with the guessed `cl.exe` path, and the `MSVC` include path is based on the `cl.exe` path.
 * Fix files under a non-recursive `browse.path` being removed from the database.
 * Fix `*` not working in `browse.path` with WSL.
-* Fix for -break-insert main returning multiple bind points. [#729](https://github.com/Microsoft/MIEngine/pull/729)
-* Use -- instead of -x for gnome-terminal. [#733](https://github.com/Microsoft/MIEngine/pull/733)
-* Added `miDebuggerArgs` in order to pass arguments to the program in `miDebuggerPath`. [#720](https://github.com/Microsoft/MIEngine/pull/720)
+* Fix -break-insert main returning multiple bind points. [PR Microsoft/MIEngine#729](https://github.com/Microsoft/MIEngine/pull/729)
+* Use -- instead of -x for gnome-terminal. [PR Microsoft/MIEngine#733](https://github.com/Microsoft/MIEngine/pull/733)
+* Added `miDebuggerArgs` in order to pass arguments to the program in `miDebuggerPath`. [PR Microsoft/MIEngine#720](https://github.com/Microsoft/MIEngine/pull/720)
 
 ## Version 0.17.4: May 31, 2018
 * Fix infinite loop (caused by deadlock) when using recursive includes. [#2043](https://github.com/Microsoft/vscode-cpptools/issues/2043)
@@ -254,9 +407,9 @@
 * Add `C_Cpp.exclusionPolicy` default to `checkFolders` to avoid expensive `files.exclude` checking on every file.
 
 ## Version 0.14.5: December 18, 2017
-* Fix for stackwalk `NullReferenceException`. [#1339](https://github.com/Microsoft/vscode-cpptools/issues/1339)
-* Fix for `-isystem` (or `-I`) not being used in `compile_commands.json` if there's a space after it. [#1343](https://github.com/Microsoft/vscode-cpptools/issues/1343)
-* Fix for header switching from `.cc` to `.hpp` files (and other cases). [#1341](https://github.com/Microsoft/vscode-cpptools/issues/1341)
+* Fix stackwalk `NullReferenceException`. [#1339](https://github.com/Microsoft/vscode-cpptools/issues/1339)
+* Fix `-isystem` (or `-I`) not being used in `compile_commands.json` if there's a space after it. [#1343](https://github.com/Microsoft/vscode-cpptools/issues/1343)
+* Fix header switching from `.cc` to `.hpp` files (and other cases). [#1341](https://github.com/Microsoft/vscode-cpptools/issues/1341)
 * Fix reload prompts not appearing in debugging scenarios (after the initial installation). [#1344](https://github.com/Microsoft/vscode-cpptools/issues/1344)
 * Add a "wait" message when commands are invoked during download/installation. [#1344](https://github.com/Microsoft/vscode-cpptools/issues/1344)
 * Prevent blank "C/C++ Configuration" from appearing when debugging is started but the language service is not. [#1353](https://github.com/Microsoft/vscode-cpptools/issues/1353)
@@ -275,9 +428,9 @@
 * Improve performance for fetching call stacks with large arguments. [#363](https://github.com/Microsoft/vscode-cpptools/issues/363)
 
 ## Version 0.14.3: November 27, 2017
-* Fix for disappearing parameter hints tooltip. [#1165](https://github.com/Microsoft/vscode-cpptools/issues/1165)
-* Fix for parameter hints only showing up after the opening parenthesis. [#902](https://github.com/Microsoft/vscode-cpptools/issues/902), [#819](https://github.com/Microsoft/vscode-cpptools/issues/819)
-* Fix for customer reported crashes in the TypeScript extension code. [#1240](https://github.com/Microsoft/vscode-cpptools/issues/1240), [#1245](https://github.com/Microsoft/vscode-cpptools/issues/1245)
+* Fix disappearing parameter hints tooltip. [#1165](https://github.com/Microsoft/vscode-cpptools/issues/1165)
+* Fix parameter hints only showing up after the opening parenthesis. [#902](https://github.com/Microsoft/vscode-cpptools/issues/902), [#819](https://github.com/Microsoft/vscode-cpptools/issues/819)
+* Fix customer reported crashes in the TypeScript extension code. [#1240](https://github.com/Microsoft/vscode-cpptools/issues/1240), [#1245](https://github.com/Microsoft/vscode-cpptools/issues/1245)
 * Fix .browse.VC-#.db files being unnecessarily created when an shm file exists. [#1234](https://github.com/Microsoft/vscode-cpptools/issues/1234)
 * Fix language service to only activate after a C/C++ file is opened or a C/Cpp command is used (not onDebug).
 * Fix database resetting if shutdown got blocked by an IntelliSense operation. [#1260](https://github.com/Microsoft/vscode-cpptools/issues/1260)
@@ -345,7 +498,7 @@
 * Support `${env:VAR}` syntax for environment variables in `c_cpp_properties.json`. [#1000](https://github.com/Microsoft/vscode-cpptools/issues/1000)
 * Support semicolon delimiters for include paths in `c_cpp_properties.json` to better support environment variables. [#1001](https://github.com/Microsoft/vscode-cpptools/issues/1001)
 * Add `__LITTLE_ENDIAN__=1` to default defines so that "endian.h" is not needed on Mac projects. [#1005](https://github.com/Microsoft/vscode-cpptools/issues/1005)
-* Fix for source code files on Windows with incorrect casing. [#984](https://github.com/Microsoft/vscode-cpptools/issues/984)
+* Fix source code files on Windows with incorrect casing. [#984](https://github.com/Microsoft/vscode-cpptools/issues/984)
 
 ## Version 0.12.3: August 17, 2017
 * Fix regression for paths containing multibyte characters. [#958](https://github.com/Microsoft/vscode-cpptools/issues/958)
@@ -381,7 +534,7 @@
 * Update Microsoft Visual C++ debugger to Visual Studio 2017 released components.
   * Fix issue with showing wrong thread. [#550](https://github.com/Microsoft/vscode-cpptools/issues/550)
   * Fix issue with binaries compiled with /FASTLINK causing debugger to hang. [#484](https://github.com/Microsoft/vscode-cpptools/issues/484)
-* Fix issue in MinGW/Cygwin debugging where stop debugging causes VS Code to hang. [Microsoft/MIEngine#636](https://github.com/Microsoft/MIEngine/pull/636)
+* Fix issue in MinGW/Cygwin debugging where stop debugging causes VS Code to hang. [PR Microsoft/MIEngine#636](https://github.com/Microsoft/MIEngine/pull/636)
 
 ## Version 0.12.0: June 26, 2017
 * The default IntelliSense engine now provides semantic-aware autocomplete suggestions for `.`, `->`, and `::` operators. [#13](https://github.com/Microsoft/vscode-cpptools/issues/13)
@@ -398,8 +551,8 @@
 * Fix `Go to Definition` not working until all `browse.path` files are re-scanned. [#788](https://github.com/Microsoft/vscode-cpptools/issues/788)
 
 ## Version 0.11.4: June 2, 2017
-* Fix for `System.Xml.Serialization.XmlSerializationReader threw an exception` when debugging on Linux. [#792](https://github.com/Microsoft/vscode-cpptools/issues/792)
-* Fix for escaping for `${workspaceRoot}` in `launch.json`.
+* Fix `System.Xml.Serialization.XmlSerializationReader threw an exception` when debugging on Linux. [#792](https://github.com/Microsoft/vscode-cpptools/issues/792)
+* Fix escaping for `${workspaceRoot}` in `launch.json`.
 
 ## Version 0.11.3: May 31, 2017
 * Fix `x86_64-pc-linux-gnu` and `x86_64-linux-gnu` paths missing from the default `includePath`.
@@ -447,7 +600,7 @@
 
 ## Version 0.10.5: March 21, 2017
 * Fix a crash that randomly occurred when the size of a document increased. [#430](https://github.com/Microsoft/vscode-cpptools/issues/430)
-* Fix for browsing not working for Linux/Mac stdlib.h functions. [#578](https://github.com/Microsoft/vscode-cpptools/issues/578)
+* Fix browsing not working for Linux/Mac stdlib.h functions. [#578](https://github.com/Microsoft/vscode-cpptools/issues/578)
 * Additional fixes for switch header/source not respecting `files.exclude`. [#485](https://github.com/Microsoft/vscode-cpptools/issues/485)
 * Made `editor.quickSuggestions` dependent on `C_Cpp.autocomplete`. [#572](https://github.com/Microsoft/vscode-cpptools/issues/572)
   * We recommend you close and reopen your settings.json file anytime you change the `C_Cpp.autocomplete` setting. [More info here](https://github.com/Microsoft/vscode-cpptools/releases).

Extension/README.md

@@ -2,7 +2,7 @@
 This preview release of the extension adds language support for C/C++ to Visual Studio Code including:
 * Language service
   * Code Formatting (clang-format)
-  * Auto-Completion (experimental)
+  * Auto-Completion
   * Symbol Searching
   * Go to Definition/Declaration
   * Peek Definition/Declaration
@@ -23,5 +23,12 @@ This preview release of the extension adds language support for C/C++ to Visual
 
 You can find more detailed information about C/C++ support for Visual Studio Code at our [GitHub page](https://github.com/Microsoft/vscode-cpptools/tree/master/Documentation) and our [VS Code documentation page](https://code.visualstudio.com/docs/languages/cpp).
 
+## Installation
+The extension has OS-specific binary dependencies, so installation via the Marketplace requires an Internet connection so that these additional dependencies can be downloaded. If you are working on a computer that does not have access to the Internet or is behind a strict firewall, you may need to use our OS-specific packages and install them by invoking VS Code's `"Install from VSIX..."` command. These "offline' packages are available at: https://github.com/Microsoft/vscode-cpptools/releases.
+* `cpptools-linux.vsix` - for 64-bit Linux
+* `cpptools-linux32.vsix` - for 32-bit Linux
+* `cpptools-osx.vsix` - for macOS
+* `cpptools-win32.vsix` - for 64-bit & 32-bit Windows
+
 ## Contact Us
-If you run into any issues or have suggestions for us, please file [issues and suggestions on GitHub](https://github.com/Microsoft/vscode-cpptools/issues). If you haven’t already provided us feedback, please take this [quick survey](https://www.research.net/r/VBVV6C6) to help shape this extension for your needs.
+If you run into any issues or have suggestions for us, please file [issues and suggestions on GitHub](https://github.com/Microsoft/vscode-cpptools/issues). If you haven’t already provided us feedback, please take this [quick survey](https://www.research.net/r/VBVV6C6) and let us know what you think!

Extension/ReleaseNotes.html

@@ -205,8 +205,21 @@
                         <tr>
                             <td>
                                 <div>
-                                    <h2 class="caption">October 2018 Update</h2>
-                                    <div>Thank you for installing the C/C++ extension. In the October update, we finished our semantic-aware implementation of Go To Definition. We also added IntegratedTerminal support for debugging.<br/>
+                                    <h2 class="caption">May 2019 Update</h2>
+                                    <div>Thank you for installing the C/C++ extension! We're excited to announce the following features in the May update:<br/>
+                                        <h3 style="font-weight: 600">IntelliSense configuration settings editor UI</h3>
+                                        The extension now has a UI editor to edit basic IntelliSense configuration settings defined in the underlying <code>c_cpp_properties.json</code> file.<br/>
+                                        <br/>
+                                        You can get to the IntelliSense configuration settings editor UI through the command palette (Ctrl+Shift+P) and running the <code>C/C++: Edit configurations (UI)</code> command.
+                                        The <code>c_cpp_properties.json</code> file can be opened by running the <code>C/C++: Edit configurations (JSON)</code> command.
+                                        <br/>
+                                        <br/>
+                                        <em style="font-weight: 600">Please Note:</em> When configuring IntelliSense for the first time, VS Code will open the UI editor or JSON file based on your <code>workbench.settings.editor</code> setting.
+                                        If <code>workbench.settings.editor</code> is set to “ui”, then the UI editor will open by default, and if it is set to “json”, then the JSON file will open by default. You can view that setting under VS Code preferences → settings → “Workbench Settings Editor”.<br/>
+
+                                        <h3 style="font-weight: 600">Log diagnostics command</h3>
+                                        We added the command <code>C/C++: Log Diagnostics</code> to help diagnose IntelliSense issues. Running the command shows IntelliSense information of the current translation unit that is associated with the active file.<br/>
+                                        <br/>
                                         <br/>
                                         Additional features and bug fixes are detailed in the <a href="https://github.com/Microsoft/vscode-cpptools/releases">full release notes</a>.</div>
                                 </div>
@@ -231,10 +244,9 @@
                             <td>
                                 <div>
                                     <h3 class="caption">Blog Posts</h3>
-                                    <div><a href="https://blogs.msdn.microsoft.com/vcblog/2018/08/23/visual-studio-code-c-c-extension-august-2018-update/">August 2018 Update</a></div>
-                                    <div><a href="https://blogs.msdn.microsoft.com/vcblog/2018/07/25/visual-studio-code-cc-extension-july-2018-update-and-intellisense-auto-configuration-for-cmake/">July 2018 Update</a></div>
-                                    <div><a href="https://blogs.msdn.microsoft.com/vcblog/2018/06/21/visual-studio-code-cc-extension-june-2018-update/">June 2018 Update</a></div>
-                                    <div><a href="https://blogs.msdn.microsoft.com/vcblog/2016/03/31/cc-extension-for-visual-studio-code/">C/C++ Extension anouncement</a></div>
+                                    <div><a href="https://devblogs.microsoft.com/cppblog/vscode-cpp-may-2019-update/">May 2019 Update</a></div>
+                                    <div><a href="https://devblogs.microsoft.com/cppblog/visual-studio-code-c-c-extension-march-2019-update/">March 2019 Update</a></div>
+                                    <div><a href="https://devblogs.microsoft.com/cppblog/vs-code-cpp-extension-january-2019-update/">January 2019 Update</a></div>
                                 </div>
                             </td>
                         </tr>

Extension/assets/Refresh.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><path d="M13.451 5.609l-.579-.939-1.068.812-.076.094c-.335.415-.927 1.341-1.124 2.876l-.021.165.033.163.071.345c0 1.654-1.346 3-3 3-.795 0-1.545-.311-2.107-.868-.563-.567-.873-1.317-.873-2.111 0-1.431 1.007-2.632 2.351-2.929v2.926s2.528-2.087 2.984-2.461h.012l3.061-2.582-4.919-4.1h-1.137v2.404c-3.429.318-6.121 3.211-6.121 6.721 0 1.809.707 3.508 1.986 4.782 1.277 1.282 2.976 1.988 4.784 1.988 3.722 0 6.75-3.028 6.75-6.75 0-1.245-.349-2.468-1.007-3.536z" fill="#F6F6F6"/><path d="M12.6 6.134l-.094.071c-.269.333-.746 1.096-.91 2.375.057.277.092.495.092.545 0 2.206-1.794 4-4 4-1.098 0-2.093-.445-2.817-1.164-.718-.724-1.163-1.718-1.163-2.815 0-2.206 1.794-4 4-4l.351.025v1.85s1.626-1.342 1.631-1.339l1.869-1.577-3.5-2.917v2.218l-.371-.03c-3.176 0-5.75 2.574-5.75 5.75 0 1.593.648 3.034 1.695 4.076 1.042 1.046 2.482 1.694 4.076 1.694 3.176 0 5.75-2.574 5.75-5.75-.001-1.106-.318-2.135-.859-3.012z" fill="#424242"/></svg>

Extension/assets/Refresh_inverse.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><path d="M13.451 5.609l-.579-.939-1.068.812-.076.094c-.335.415-.927 1.341-1.124 2.876l-.021.165.033.163.071.345c0 1.654-1.346 3-3 3-.795 0-1.545-.311-2.107-.868-.563-.567-.873-1.317-.873-2.111 0-1.431 1.007-2.632 2.351-2.929v2.926s2.528-2.087 2.984-2.461h.012l3.061-2.582-4.919-4.1h-1.137v2.404c-3.429.318-6.121 3.211-6.121 6.721 0 1.809.707 3.508 1.986 4.782 1.277 1.282 2.976 1.988 4.784 1.988 3.722 0 6.75-3.028 6.75-6.75 0-1.245-.349-2.468-1.007-3.536z" fill="#2D2D30"/><path d="M12.6 6.134l-.094.071c-.269.333-.746 1.096-.91 2.375.057.277.092.495.092.545 0 2.206-1.794 4-4 4-1.098 0-2.093-.445-2.817-1.164-.718-.724-1.163-1.718-1.163-2.815 0-2.206 1.794-4 4-4l.351.025v1.85s1.626-1.342 1.631-1.339l1.869-1.577-3.5-2.917v2.218l-.371-.03c-3.176 0-5.75 2.574-5.75 5.75 0 1.593.648 3.034 1.695 4.076 1.042 1.046 2.482 1.694 4.076 1.694 3.176 0 5.75-2.574 5.75-5.75-.001-1.106-.318-2.135-.859-3.012z" fill="#C5C5C5"/></svg>

Extension/c_cpp_properties.schema.json

@@ -112,9 +112,11 @@
                                     "type": "string"
                                 }
                             }
-                        }
+                        },
+                        "additionalProperties": false
                     }
-                }
+                },
+                "additionalProperties": false
             }
         },
         "env": {
@@ -140,6 +142,11 @@
         "version": {
             "type": "integer",
             "description": "Version of the configuration file. This property is managed by the extension. Please do not change it."
+        },
+        "enableConfigurationSquiggles": {
+            "type": "boolean",
+            "default": true,
+            "description": "Controls whether the extension will report errors detected in c_cpp_properties.json."
         }
     },
     "properties": {
@@ -151,10 +158,14 @@
         },
         "version": {
             "$ref": "#/definitions/version"
+        },
+        "enableConfigurationSquiggles": {
+            "$ref": "#/definitions/enableConfigurationSquiggles"
         }
     },
     "required": [
         "configurations",
         "version"
-    ]
+    ],
+    "additionalProperties": false
 }

Extension/cpp_snippets.json

@@ -1,140 +0,0 @@
-{
-  "class": {
-    "prefix": "class",
-    "body": "\nclass ${1:${TM_FILENAME_BASE}}\n{\nprivate:\n\t${2:/* data */}\npublic:\n\t${1}(${3:/* args */});\n\t~${1}();\n};\n\n${1}::${1}(${3})\n{\n}\n\n${1}::~${1}()\n{\n}\n",
-    "description": "Code snippet for class",
-    "scope": "source.c++, source.objc++"
-  },
-  "classi": {
-    "prefix": "classi",
-    "body": "\nclass ${1:${TM_FILENAME_BASE}}\n{\nprivate:\n\t${2:/* data */}\npublic:\n\t${1}(${3:/* args */}) { $0}\n\t~${1}() { }\n};",
-    "description": "Code snippet for class with inlined constructor/destructor",
-    "scope": "source.c++, source.objc++"
-  },
-  "classt": {
-    "prefix": "classt",
-    "body": "\ntemplate<typename T>\nclass ${1:${TM_FILENAME_BASE}}\n{\nprivate:\n\tT ${2:/* data */}\npublic:\n\t${1}(T ${3:/* args */});\n};\n",
-    "description": "Code snippet for class template",
-    "scope": "source.c++, source.objc++"
-  },
-  "struct": {
-    "prefix": "struct",
-    "body": "\nstruct ${1:${TM_FILENAME_BASE}}\n{\n\t${0:/* data */}\n};\n",
-    "description": "Code snippet for struct",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "union": {
-    "prefix": "union",
-    "body": "\nunion ${1:${TM_FILENAME_BASE}}\n{\n\t${0:/* data */}\n};\n",
-    "description": "Code snippet for union",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "if": {
-    "prefix": "if",
-    "body": "\nif (${1:/* condition */}) {\n\t${0:/* code */}\n}\n",
-    "description": "Code snippet for if()",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "ifel": {
-    "prefix": "ifel",
-    "body": "\nif (${1:/* condition */}) {\n\t${2:/* code */}\n}\nelse {\n\t${0:/* code */}\n}\n",
-    "description": "Code snippet for if() else",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "ifelif": {
-    "prefix": "ifelif",
-    "body": "\nif (${1:/* condition */}) {\n\t${2:/* code */}\n}\nelse if(${3:/* condition */}) {\n\t${4:/* code */}\n}\nelse {\n\t${0:/* code */}\n}\n",
-    "description": "Code snippet for if() else if() else",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "else": {
-    "prefix": "else",
-    "body": "\nelse\n{\n\t${0:/* code */}\n}\n",
-    "description": "Code snippet for else",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "elif": {
-    "prefix": "elif",
-    "body": "\nelse if (${1:/* condition */})\n{\n\t${0:/* code */}\n}\n",
-    "description": "Code snippet for else if ()",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "switch": {
-    "prefix": "switch",
-    "body": "\nswitch (${1:expression})\n{\n\tcase ${2:/* constant-expression */}:\n\t\t${3:/* code */}\n\t\tbreak;\n\n\tdefault:\n\t\tbreak;\n}",
-    "description": "Code snippet for switch",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "main": {
-    "prefix": "main",
-    "body": "main(int argc, char const *argv[])\n{\n\t${1:/* code */}\n\treturn 0;\n}\n",
-    "description": "Code snippet for main()",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "do": {
-    "prefix": "do_",
-    "body": "\ndo\n{\n\t${0:/* code */}\n} while (${1:/* condition */});\n",
-    "description": "Code snippet for do while loop",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "for": {
-    "prefix": "for",
-    "body": "\nfor(${1:size_t} ${2:i} = 0; $2 < ${3:count}; ${4:$2++})\n{\n\t${0:/* code */}\n}\n",
-    "description": "Code snippet for for loop",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "forr": {
-    "prefix": "forr",
-    "body": "\nfor(int ${1:i} = ${2:length} - 1; $1 >= 0; ${3:$1--})\n{\n\t${0:/* code */}\n}\n",
-    "description": "Code snippet for reverse for loop",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "foreach": {
-    "prefix": "foreach",
-    "body": "\nfor(${1:object} = ${2:var} in ${3:collection})\n{\n\t${0:/* code */}\n}\n",
-    "description": "Code snippet for foreach loop",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "forrange": {
-    "prefix": "forrange",
-    "body": "\nfor(auto&& ${1:i} : ${2:v})\n{\n\t$0\n}\n",
-    "description": "Code snippet for range-based forloop",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "while": {
-    "prefix": "while",
-    "body": "\nwhile(${1:/* condition */}){\n\t${2:/* code */}\n}\n",
-    "description": "Code snippet for while loop",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "ifd": {
-    "prefix": "ifnd",
-    "body": "\n#if defined($1)\n\n${0}\n\n#endif // $1\n",
-    "description": "Code snippet for if defined()",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "ifnd": {
-    "prefix": "ifnd",
-    "body": "\n#if !defined($1)\n#define ${1:MACRO}\n\n${0}\n\n#endif // $1\n",
-    "description": "Code snippet for if !defined()",
-    "scope": "source.c, source.objc, source.c++, source.objc++"
-  },
-  "mitl": {
-    "prefix": "mitl",
-    "body": "\n// The MIT License (MIT)\n\n// Copyright (c) ${1:YEAR} ${2:NAME}\n\n//  Permission is hereby granted, free of charge, to any person obtaining a\n//  copy of this software and associated documentation files (the \"Software\"),\n//  to deal in the Software without restriction, including without limitation\n//  the rights to use, copy, modify, merge, publish, distribute, sublicense,\n//  and/or sell copies of the Software, and to permit persons to whom the\n//  Software is furnished to do so, subject to the following conditions:\n//\n//  The above copyright notice and this permission notice shall be included in\n//  all copies or substantial portions of the Software.\n//\n//  THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n//  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n//  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n//  DEALINGS IN THE SOFTWARE.\n\n${0:/* code */}\n",
-    "description": "Code snippet for MIT License",
-    "scope": ""
-  },
-  "namesp": {
-    "prefix": "namesp",
-    "body": "\nnamespace ${1:name}\n{\n\t$0\n} // $1\n",
-    "description": "Code snippet for namespace",
-    "scope": "source.c++, source.objc++"
-  },
-  "try": {
-    "prefix": "try",
-    "body": "\ntry\n{\n\t${1:/* code */}\n}\ncatch(${2:const std::exception& e})\n{\n\t${0:std::cerr << e.what() << '\\n';}\n}\n",
-    "description": "Code snippet for try catch block",
-    "scope": "source.c++, source.objc++, source.c++11"
-  }
-}

Extension/gulpfile.js

@@ -29,28 +29,9 @@ gulp.task('unitTests', (done) => {
         });
 });
 
-gulp.task('integrationTests', (done) => {
-    env.set({
-            CODE_TESTS_PATH: "./out/test/integrationTests",
-            CODE_TESTS_WORKSPACE: "./test/integrationTests/testAssets/SimpleCppProject"
-        });
-
-    return gulp.src('./test/runVsCodeTestsWithAbsolutePaths.js', {read: false})
-        .pipe(mocha({ ui: "tdd" }))
-        .once('error', err => {
-            done();
-            process.exit(1);
-        })
-        .once('end', () => {
-            done();
-            process.exit();
-        });
-});
-
 /// Misc Tasks
 const allTypeScript = [
     'src/**/*.ts',
-    'tools/**/*.ts',
     '!**/*.d.ts',
     '!**/typings**'
 ];

Extension/jobs/build.windows.yml

@@ -0,0 +1,52 @@
+parameters:
+  name: ''
+  pool: ''
+
+jobs:
+- job: Windows
+  pool:
+    vmImage: 'vs2017-win2016'
+
+  steps:
+  - task: NodeTool@0
+    displayName: 'Use Node 8.x'
+    inputs:
+      versionSpec: 8.x
+
+  - script: npm install
+    displayName: "Install Dependencies"
+    workingDirectory: '$(Build.SourcesDirectory)\Extension'
+
+  - script: npm run compile
+    displayName: "Compile Sources"
+    workingDirectory: '$(Build.SourcesDirectory)\Extension'
+
+  - script: npm run pr-check
+    displayName: 'Validate Extension/package.json'
+    workingDirectory: '$(Build.SourcesDirectory)\Extension'
+
+  - script: npm run tslint
+    displayName: 'Run Linter'
+    workingDirectory: '$(Build.SourcesDirectory)\Extension'
+
+  - script: 'npm run unitTests'
+    displayName: 'Run unit tests'
+    workingDirectory: '$(Build.SourcesDirectory)\Extension'
+    continueOnError: true
+
+  - script: npm run pretest
+    displayName: "Compile Test Sources"
+    workingDirectory: '$(Build.SourcesDirectory)\Extension'
+
+  - script: 'node node_modules/vscode/bin/test'
+    displayName: 'Run languageServer integration tests'
+    workingDirectory: '$(Build.SourcesDirectory)\Extension'
+    env:
+      CODE_TESTS_PATH: '$(Build.SourcesDirectory)\Extension\out\test\integrationTests\languageServer'
+      CODE_EXTENSIONS_PATH: '$(Build.SourcesDirectory)\Extension'
+      CODE_TESTS_WORKSPACE: '$(Build.SourcesDirectory)\Extension\test\integrationTests\testAssets\SimpleCppProject'
+      CODE_DISABLE_EXTENSIONS: 1
+
+  - task: ms.vss-governance-buildtask.governance-build-task-component-detection.ComponentGovernanceComponentDetection@0
+    displayName: 'Component Detection'
+    continueOnError: true

Extension/jobs/build.yml

@@ -0,0 +1,58 @@
+parameters:
+  name: ''
+  pool: ''
+
+jobs:
+- job: ${{ parameters.name }}
+  pool: ${{ parameters.pool }}
+
+  steps:
+  - task: NodeTool@0
+    displayName: 'Use Node 8.x'
+    inputs:
+      versionSpec: 8.x
+
+  - script: npm install
+    displayName: "Install Dependencies"
+    workingDirectory: '$(Build.SourcesDirectory)/Extension'
+
+  - script: npm run compile
+    displayName: "Compile Sources"
+    workingDirectory: '$(Build.SourcesDirectory)/Extension'
+
+  - script: npm run pr-check
+    displayName: 'Validate Extension/package.json'
+    workingDirectory: '$(Build.SourcesDirectory)/Extension'
+
+  - script: npm run tslint
+    displayName: 'Run Linter'
+    workingDirectory: '$(Build.SourcesDirectory)/Extension'
+
+  - script: 'npm run unitTests'
+    displayName: 'Run unit tests'
+    workingDirectory: '$(Build.SourcesDirectory)/Extension'
+    continueOnError: true
+
+  - script: |
+      set -e
+      /usr/bin/Xvfb :10 -ac >> /tmp/Xvfb.out 2>&1 &
+      disown -ar
+    displayName: 'Start xvfb'
+
+  - script: npm run pretest
+    displayName: "Compile Test Sources"
+    workingDirectory: '$(Build.SourcesDirectory)/Extension'
+
+  - script: 'node node_modules/vscode/bin/test'
+    displayName: 'Run languageServer integration tests'
+    workingDirectory: '$(Build.SourcesDirectory)/Extension'
+    env:
+      DISPLAY: :10
+      CODE_TESTS_PATH: '$(Build.SourcesDirectory)/Extension/out/test/integrationTests/languageServer'
+      CODE_EXTENSIONS_PATH: '$(Build.SourcesDirectory)/Extension'
+      CODE_TESTS_WORKSPACE: '$(Build.SourcesDirectory)/Extension/test/integrationTests/testAssets/SimpleCppProject'
+      CODE_DISABLE_EXTENSIONS: 1
+
+  - task: ms.vss-governance-buildtask.governance-build-task-component-detection.ComponentGovernanceComponentDetection@0
+    displayName: 'Component Detection'
+    continueOnError: true

Extension/package.json

@@ -2,7 +2,7 @@
   "name": "cpptools",
   "displayName": "C/C++",
   "description": "C/C++ IntelliSense, debugging, and code browsing.",
-  "version": "0.20.1",
+  "version": "0.23.1",
   "publisher": "ms-vscode",
   "preview": true,
   "icon": "LanguageCCPP_color_128x.png",
@@ -12,7 +12,7 @@
   },
   "license": "SEE LICENSE IN LICENSE.txt",
   "engines": {
-    "vscode": "^1.23.0"
+    "vscode": "^1.30.0"
   },
   "bugs": {
     "url": "https://github.com/Microsoft/vscode-cpptools/issues",
@@ -41,7 +41,7 @@
   "activationEvents": [
     "*"
   ],
-  "main": "./out/src/main",
+  "main": "./dist/main",
   "contributes": {
     "problemMatchers": [
       {
@@ -77,13 +77,13 @@
         "C_Cpp.clang_format_style": {
           "type": "string",
           "default": "file",
-          "description": "Coding style, currently supports: Visual Studio, LLVM, Google, Chromium, Mozilla, WebKit. Use \"file\" to load the style from a .clang-format file in the current or parent directory. Use \"{key: value, ...}\" to set specific parameters, e.g.: \"{ BasedOnStyle: LLVM, IndentWidth: 8 }\"",
+          "description": "Coding style, currently supports: Visual Studio, LLVM, Google, Chromium, Mozilla, WebKit. Use \"file\" to load the style from a .clang-format file in the current or parent directory. Use {key: value, ...} to set specific parameters. For example, the \"Visual Studio\" style is similar to: { BasedOnStyle: LLVM, UseTab: Never, IndentWidth: 4, TabWidth: 4, BreakBeforeBraces: Allman, AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: false, ColumnLimit: 0, AccessModifierOffset: -4 }",
           "scope": "resource"
         },
         "C_Cpp.clang_format_fallbackStyle": {
           "type": "string",
           "default": "Visual Studio",
-          "description": "Name of the predefined style used as a fallback in case clang-format is invoked with style \"file\" but the .clang-format file is not found. Possible values are Visual Studio, LLVM, Google, Chromium, Mozilla, WebKit, none, or use \"{key: value, ...}\" to set specific parameters, e.g.: \"{ BasedOnStyle: LLVM, IndentWidth: 8 }\"",
+          "description": "Name of the predefined style used as a fallback in case clang-format is invoked with style \"file\" but the .clang-format file is not found. Possible values are Visual Studio, LLVM, Google, Chromium, Mozilla, WebKit, none, or use {key: value, ...} to set specific parameters. For example, the \"Visual Studio\" style is similar to: { BasedOnStyle: LLVM, UseTab: Never, IndentWidth: 4, TabWidth: 4, BreakBeforeBraces: Allman, AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: false, ColumnLimit: 0, AccessModifierOffset: -4 }",
           "scope": "resource"
         },
         "C_Cpp.clang_format_sortIncludes": {
@@ -117,7 +117,7 @@
             "Enabled",
             "Disabled"
           ],
-          "default": "Enabled",
+          "default": "Disabled",
           "description": "Controls whether the IntelliSense engine will automatically switch to the Tag Parser for translation units containing #include errors.",
           "scope": "resource"
         },
@@ -135,10 +135,11 @@
           "type": "string",
           "enum": [
             "Enabled",
-            "Disabled"
+            "Disabled",
+            "EnabledIfIncludesResolve"
           ],
-          "default": "Enabled",
-          "description": "Controls whether suspected compile errors detected by the IntelliSense engine will be reported back to the editor. Warnings about #includes that could not be located will always be reported to the editor. This setting is ignored by the Tag Parser engine.",
+          "default": "EnabledIfIncludesResolve",
+          "description": "Controls whether suspected compile errors detected by the IntelliSense engine will be reported back to the editor. This setting is ignored by the Tag Parser engine.",
           "scope": "resource"
         },
         "C_Cpp.dimInactiveRegions": {
@@ -289,6 +290,19 @@
           "description": "Determines whether pop up notifications will be shown when a configuration provider extension is unable to provide a configuration for a source file.",
           "scope": "resource"
         },
+        "C_Cpp.intelliSenseCachePath": {
+          "type": "string",
+          "default": "${workspaceFolder}/.vscode",
+          "description": "Defines the folder path for cached precompiled headers used by IntelliSense. The default path \"${workspaceFolder}/.vscode\" will be used if a specified path is invalid.",
+          "scope": "resource"
+        },
+        "C_Cpp.intelliSenseCacheSize": {
+          "type": "number",
+          "default": 5120,
+          "description": "Maximum size of the per-workspace hard drive space in megabytes for cached precompiled headers; the actual usage may fluctuate around this value. The default size is 5120 MB. Precompiled header caching is disabled when the size is 0.",
+          "scope": "resource",
+          "minimum": 0
+        },
         "C_Cpp.default.includePath": {
           "type": [
             "array",
@@ -457,6 +471,15 @@
           "description": "The value to use for the system include path. If set, it overrides the system include path acquired via \"compilerPath\" and \"compileCommands\" settings.",
           "scope": "resource"
         },
+        "C_Cpp.default.enableConfigurationSquiggles": {
+          "type": [
+            "boolean",
+            "null"
+          ],
+          "default": null,
+          "description": "Controls whether the extension will report errors detected in c_cpp_properties.json.",
+          "scope": "resource"
+        },
         "C_Cpp.updateChannel": {
           "type": "string",
           "enum": [
@@ -466,94 +489,115 @@
           "default": "Default",
           "description": "Set to \"Insiders\" to automatically download and install the latest Insiders builds of the extension, which include upcoming features and bug fixes.",
           "scope": "resource"
+        },
+        "C_Cpp.suggestSnippets": {
+          "type": "boolean",
+          "default": true,
+          "description": "If true, snippets are provided by the language server.",
+          "scope": "resource"
         }
       }
     },
     "commands": [
       {
         "command": "C_Cpp.ConfigurationSelect",
-        "title": "Select a Configuration...",
-        "category": "C/Cpp"
+        "title": "%c_cpp.command.configurationSelect.title%",
+        "category": "C/C++"
       },
       {
         "command": "C_Cpp.ConfigurationProviderSelect",
-        "title": "Change Configuration Provider...",
-        "category": "C/Cpp"
+        "title": "%c_cpp.command.configurationProviderSelect.title%",
+        "category": "C/C++"
       },
       {
-        "command": "C_Cpp.ConfigurationEdit",
-        "title": "Edit Configurations...",
-        "category": "C/Cpp"
+        "command": "C_Cpp.ConfigurationEditJSON",
+        "title": "%c_cpp.command.configurationEditJSON.title%",
+        "category": "C/C++"
+      },
+      {
+        "command": "C_Cpp.ConfigurationEditUI",
+        "title": "%c_cpp.command.configurationEditUI.title%",
+        "category": "C/C++"
       },
       {
         "command": "C_Cpp.GoToDeclaration",
-        "title": "Go to Declaration",
-        "category": "C/Cpp"
+        "title": "%c_cpp.command.goToDeclaration.title%",
+        "category": "C/C++"
       },
       {
         "command": "C_Cpp.PeekDeclaration",
-        "title": "Peek Declaration",
-        "category": "C/Cpp"
+        "title": "%c_cpp.command.peekDeclaration.title%",
+        "category": "C/C++"
       },
       {
         "command": "C_Cpp.SwitchHeaderSource",
-        "title": "Switch Header/Source",
-        "category": "C/Cpp"
+        "title": "%c_cpp.command.switchHeaderSource.title%",
+        "category": "C/C++"
       },
       {
         "command": "C_Cpp.Navigate",
-        "title": "Navigate...",
-        "category": "C/Cpp"
+        "title": "%c_cpp.command.navigate.title%",
+        "category": "C/C++"
       },
       {
-        "command": "C_Cpp.ToggleSnippets",
-        "title": "Toggle Snippets",
-        "category": "C/Cpp"
+        "command": "C_Cpp.EnableErrorSquiggles",
+        "title": "%c_cpp.command.enableErrorSquiggles.title%",
+        "category": "C/C++"
       },
       {
-        "command": "C_Cpp.ToggleErrorSquiggles",
-        "title": "Toggle Error Squiggles",
-        "category": "C/Cpp"
+        "command": "C_Cpp.DisableErrorSquiggles",
+        "title": "%c_cpp.command.disableErrorSquiggles.title%",
+        "category": "C/C++"
       },
       {
         "command": "C_Cpp.ToggleIncludeFallback",
-        "title": "Toggle IntelliSense Engine Fallback on Include Errors",
-        "category": "C/Cpp"
+        "title": "%c_cpp.command.toggleIncludeFallback.title%",
+        "category": "C/C++"
       },
       {
         "command": "C_Cpp.ToggleDimInactiveRegions",
-        "title": "Toggle Inactive Region Colorization",
-        "category": "C/Cpp"
+        "title": "%c_cpp.command.toggleDimInactiveRegions.title%",
+        "category": "C/C++"
       },
       {
         "command": "C_Cpp.ShowReleaseNotes",
-        "title": "Show Release Notes",
-        "category": "C/Cpp"
+        "title": "%c_cpp.command.showReleaseNotes.title%",
+        "category": "C/C++"
       },
       {
         "command": "C_Cpp.ResetDatabase",
-        "title": "Reset IntelliSense Database",
-        "category": "C/Cpp"
+        "title": "%c_cpp.command.resetDatabase.title%",
+        "category": "C/C++"
       },
       {
         "command": "C_Cpp.PauseParsing",
-        "title": "Pause Parsing",
-        "category": "C/Cpp"
+        "title": "%c_cpp.command.pauseParsing.title%",
+        "category": "C/C++"
       },
       {
         "command": "C_Cpp.ResumeParsing",
-        "title": "Resume Parsing",
-        "category": "C/Cpp"
+        "title": "%c_cpp.command.resumeParsing.title%",
+        "category": "C/C++"
       },
       {
         "command": "C_Cpp.ShowParsingCommands",
-        "title": "Show Parsing Commands",
-        "category": "C/Cpp"
+        "title": "%c_cpp.command.showParsingCommands.title%",
+        "category": "C/C++"
       },
       {
         "command": "C_Cpp.TakeSurvey",
-        "title": "Take Survey",
-        "category": "C/Cpp"
+        "title": "%c_cpp.command.takeSurvey.title%",
+        "category": "C/C++"
+      },
+      {
+        "command": "C_Cpp.BuildAndDebugActiveFile",
+        "title": "%c_cpp.command.buildAndDebugActiveFile.title%",
+        "category": "C/C++"
+      },
+      {
+        "command": "C_Cpp.LogDiagnostics",
+        "title": "%c_cpp.command.logDiagnostics.title%",
+        "category": "C/C++"
       }
     ],
     "keybindings": [
@@ -608,7 +652,6 @@
             "cpp"
           ]
         },
-        "adapterExecutableCommand": "extension.cppdbgAdapterExecutableCommand",
         "aiKey": "AIF-d9b70cd4-b9f9-4d70-929b-a071c400b217",
         "variables": {
           "pickProcess": "extension.pickNativeProcess",
@@ -728,8 +771,12 @@
                   "type": "object",
                   "default": {},
                   "properties": {
-                    "name": "string",
-                    "value": "string"
+                    "name": {
+                      "type": "string"
+                    },
+                    "value": {
+                      "type": "string"
+                    }
                   }
                 },
                 "default": []
@@ -801,7 +848,12 @@
               },
               "externalConsole": {
                 "type": "boolean",
-                "description": "If true, a console is launched for the debuggee. If false, no console is launched. Note this option is ignored in some cases for technical reasons.",
+                "description": "If true, a console is launched for the debuggee. If false, on Linux and Windows, it will appear in the Integrated Console.",
+                "default": false
+              },
+              "avoidWindowsConsoleRedirection": {
+                "type": "boolean",
+                "description": "If true, disables debuggee console redirection that is required for Integrated Terminal support.",
                 "default": false
               },
               "sourceFileMap": {
@@ -950,12 +1002,12 @@
                 "anyOf": [
                   {
                     "type": "string",
-                    "description": "Optional process id to attach the debugger to. Use \"${command:pickProcesss}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
+                    "description": "Optional process id to attach the debugger to. Use \"${command:pickProcess}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
                     "default": "${command:pickProcess}"
                   },
                   {
                     "type": "integer",
-                    "description": "Optional process id to attach the debugger to. Use \"${command:pickProcesss}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
+                    "description": "Optional process id to attach the debugger to. Use \"${command:pickProcess}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
                     "default": 0
                   }
                 ]
@@ -1096,7 +1148,6 @@
             "cpp"
           ]
         },
-        "adapterExecutableCommand": "extension.cppvsdbgAdapterExecutableCommand",
         "aiKey": "AIF-d9b70cd4-b9f9-4d70-929b-a071c400b217",
         "variables": {
           "pickProcess": "extension.pickNativeProcess"
@@ -1140,12 +1191,21 @@
                   "type": "object",
                   "default": {},
                   "properties": {
-                    "name": "string",
-                    "value": "string"
+                    "name": {
+                      "type": "string"
+                    },
+                    "value": {
+                      "type": "string"
+                    }
                   }
                 },
                 "default": []
               },
+              "envFile": {
+                "type": "string",
+                "description": "Absolute path to a file containing environment variable definitions. These file has key value pairs sepearted by an equals sign per line. E.g. KEY=VALUE",
+                "default": "${workspaceFolder}/.env"
+              },
               "symbolSearchPath": {
                 "type": "string",
                 "description": "Semicolon separated list of directories to use to search for symbol (that is, pdb) files. Example: \"c:\\dir1;c:\\dir2\".",
@@ -1178,6 +1238,11 @@
                   "<source-path>": "<target-path>"
                 }
               },
+              "enableDebugHeap": {
+                "type": "boolean",
+                "description": "If false, the process will be launched with debug heap disabled. This sets the environment variable '_NO_DEBUG_HEAP' to '1'.",
+                "default": false
+              },
               "logging": {
                 "type": "object",
                 "description": "Optional flags to determine what types of messages should be logged to the Debug Console.",
@@ -1228,12 +1293,12 @@
                 "anyOf": [
                   {
                     "type": "string",
-                    "description": "Optional process id to attach the debugger to. Use \"${command:pickProcesss}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
+                    "description": "Optional process id to attach the debugger to. Use \"${command:pickProcess}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
                     "default": "${command:pickProcess}"
                   },
                   {
                     "type": "integer",
-                    "description": "Optional process id to attach the debugger to. Use \"${command:pickProcesss}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
+                    "description": "Optional process id to attach the debugger to. Use \"${command:pickProcess}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
                     "default": 0
                   }
                 ]
@@ -1313,112 +1378,115 @@
         {
           "when": "editorLangId == c",
           "command": "C_Cpp.SwitchHeaderSource",
-          "group": "other@1"
+          "group": "other1_navigation@1"
         },
         {
           "when": "editorLangId == cpp",
           "command": "C_Cpp.SwitchHeaderSource",
-          "group": "other@1"
+          "group": "other1_navigation@1"
         },
         {
           "when": "editorLangId == c",
           "command": "C_Cpp.Navigate",
-          "group": "other@2"
+          "group": "other1_navigation@2"
         },
         {
           "when": "editorLangId == cpp",
           "command": "C_Cpp.Navigate",
-          "group": "other@2"
+          "group": "other1_navigation@2"
         },
         {
           "when": "editorLangId == c",
           "command": "workbench.action.gotoSymbol",
-          "group": "other@3"
+          "group": "other1_navigation@3"
         },
         {
           "when": "editorLangId == cpp",
           "command": "workbench.action.gotoSymbol",
-          "group": "other@3"
+          "group": "other1_navigation@3"
         },
         {
           "when": "editorLangId == c",
           "command": "workbench.action.showAllSymbols",
-          "group": "other@4"
+          "group": "other1_navigation@4"
         },
         {
           "when": "editorLangId == cpp",
           "command": "workbench.action.showAllSymbols",
-          "group": "other@4"
+          "group": "other1_navigation@4"
+        },
+        {
+          "when": "editorLangId == cpp",
+          "command": "C_Cpp.BuildAndDebugActiveFile",
+          "group": "other2_debug@1"
+        },
+        {
+          "when": "editorLangId == c",
+          "command": "C_Cpp.BuildAndDebugActiveFile",
+          "group": "other2_debug@1"
         }
       ]
     },
     "configurationDefaults": {
       "[cpp]": {
-        "editor.autoIndent": false
+        "editor.wordBasedSuggestions": false
       },
       "[c]": {
-        "editor.autoIndent": false
+        "editor.wordBasedSuggestions": false
       }
-    },
-    "snippets": [
-      {
-        "language": "cpp",
-        "path": "./cpp_snippets.json"
-      },
-      {
-        "language": "c",
-        "path": "./cpp_snippets.json"
-      }
-    ]
+    }
   },
   "scripts": {
     "compile": "npm run vscode:prepublish",
+    "compileDev": "webpack --mode development",
     "generateOptionsSchema": "gulp generateOptionsSchema",
-    "integrationTests": "gulp integrationTests",
     "postinstall": "node ./node_modules/vscode/bin/install",
-    "pretest": "tsc -p ./",
+    "pretest": "tsc -p test.tsconfig.json",
     "pr-check": "gulp pr-check",
-    "test": "gulp allTests",
     "tslint": "gulp tslint",
     "unitTests": "gulp unitTests",
-    "vscode:prepublish": "node ./src/Support/prepublish.js",
-    "watch": "tsc -watch -p ./"
+    "vscode:prepublish": "node ./tools/prepublish.js && webpack --mode production",
+    "watch": "webpack --watch --mode development"
   },
   "devDependencies": {
-    "@types/mocha": "^2.2.43",
-    "@types/node": "^8.0.46",
+    "@types/mocha": "^5.2.6",
+    "@types/node": "^12.0.0",
     "async-child-process": "^1.1.1",
-    "child-process": "^1.0.2",
-    "gulp": "^4.0.0",
-    "gulp-env": "0.4.0",
-    "gulp-mocha": "5.0.0",
-    "gulp-tslint": "8.1.2",
-    "mocha": "^4.0.1",
-    "tslint": "5.8.0",
-    "tslint-microsoft-contrib": "5.0.1",
-    "tslint-no-unused-expression-chai": "0.0.3",
-    "typescript": "^2.5.3",
-    "vrsource-tslint-rules": "^5.8.2",
-    "vscode": "^1.1.18"
+    "await-notify": "^1.0.1",
+    "gulp": "^4.0.2",
+    "gulp-env": "^0.4.0",
+    "gulp-mocha": "^6.0.0",
+    "gulp-tslint": "^8.1.4",
+    "tslint": "^5.16.0",
+    "tslint-microsoft-contrib": "^6.1.1",
+    "tslint-no-unused-expression-chai": "^0.1.4",
+    "ts-loader": "^6.0.0",
+    "typescript": "^3.4.5",
+    "vrsource-tslint-rules": "^6.0.0",
+    "vscode": "^1.1.34",
+    "webpack": "^4.30.0",
+    "webpack-cli": "^3.3.2"
   },
   "dependencies": {
-    "http-proxy-agent": "~2.1.0",
-    "https-proxy-agent": "~2.2.0",
-    "jsonc-parser": "^1.0.0",
-    "minimatch": "~3.0.4",
-    "mkdirp": "~0.5.1",
-    "tmp": "~0.0.33",
-    "vscode-cpptools": "2.1.1",
-    "vscode-debugadapter": "~1.24.0",
-    "vscode-debugprotocol": "~1.24.0",
-    "vscode-extension-telemetry": "~0.0.22",
-    "vscode-languageclient": "3.5.1",
-    "yauzl": "~2.8.0"
+    "@types/minimatch": "^3.0.3",
+    "escape-string-regexp": "^2.0.0",
+    "http-proxy-agent": "^2.1.0",
+    "https-proxy-agent": "^2.2.1",
+    "jsonc-parser": "^2.1.0",
+    "minimatch": "^3.0.4",
+    "mkdirp": "^0.5.1",
+    "tmp": "^0.1.0",
+    "vscode-cpptools": "^2.1.2",
+    "vscode-debugadapter": "^1.34.0",
+    "vscode-debugprotocol": "^1.34.0",
+    "vscode-extension-telemetry": "^0.1.1",
+    "vscode-languageclient": "^5.2.1",
+    "yauzl": "^2.10.0"
   },
   "runtimeDependencies": [
     {
       "description": "C/C++ language components (Linux / x86_64)",
-      "url": "https://go.microsoft.com/fwlink/?linkid=2036673",
+      "url": "https://go.microsoft.com/fwlink/?linkid=2092043",
       "platforms": [
         "linux"
       ],
@@ -1432,7 +1500,7 @@
     },
     {
       "description": "C/C++ language components (Linux / x86)",
-      "url": "https://go.microsoft.com/fwlink/?linkid=2036672",
+      "url": "https://go.microsoft.com/fwlink/?linkid=2092112",
       "platforms": [
         "linux"
       ],
@@ -1448,7 +1516,7 @@
     },
     {
       "description": "C/C++ language components (OS X)",
-      "url": "https://go.microsoft.com/fwlink/?linkid=2036674",
+      "url": "https://go.microsoft.com/fwlink/?linkid=2092042",
       "platforms": [
         "darwin"
       ],
@@ -1459,7 +1527,7 @@
     },
     {
       "description": "C/C++ language components (Windows)",
-      "url": "https://go.microsoft.com/fwlink/?linkid=2036671",
+      "url": "https://go.microsoft.com/fwlink/?linkid=2092111",
       "platforms": [
         "win32"
       ],
@@ -1573,7 +1641,7 @@
     },
     {
       "description": "Visual Studio Windows Debugger",
-      "url": "https://go.microsoft.com/fwlink/?linkid=872985",
+      "url": "https://go.microsoft.com/fwlink/?linkid=2082216",
       "platforms": [
         "win32"
       ],

Extension/package.nls.it.json

@@ -0,0 +1,22 @@
+{
+    "c_cpp.command.configurationSelect.title": "Scegli una configurazione...",
+    "c_cpp.command.configurationProviderSelect.title": "Cambia provider configurazioni...",
+    "c_cpp.command.configurationEditJSON.title": "Modifica configurazioni (JSON)",
+    "c_cpp.command.configurationEditUI.title": "Modifica configurazioni (UI)",
+    "c_cpp.command.goToDeclaration.title": "Vai a dichiarazione",
+    "c_cpp.command.peekDeclaration.title": "Visualizza dichiarazione",
+    "c_cpp.command.switchHeaderSource.title": "Visualizza Header/Sorgente",
+    "c_cpp.command.navigate.title": "Naviga...",
+    "c_cpp.command.enableErrorSquiggles.title": "Attiva sottolineamento errori",
+    "c_cpp.command.disableErrorSquiggles.title": "Disattiva sottolineamento errori",
+    "c_cpp.command.toggleIncludeFallback.title": "Attiva/Disattiva motore di fallback IntelliSense negli errori di inclusione",
+    "c_cpp.command.toggleDimInactiveRegions.title": "Attiva/Disattiva colorazione regioni inattive",
+    "c_cpp.command.showReleaseNotes.title": "Mostra note di rilascio",
+    "c_cpp.command.resetDatabase.title": "Reimposta il database di IntelliSense",
+    "c_cpp.command.pauseParsing.title": "Metti in pausa l'analisi del codice",
+    "c_cpp.command.resumeParsing.title": "Riprendi l'analisi del codice",
+    "c_cpp.command.showParsingCommands.title": "Mostra comandi per l'analisi del codice",
+    "c_cpp.command.takeSurvey.title": "Partecipa al Sondaggio",
+    "c_cpp.command.buildAndDebugActiveFile.title": "Compila ed Esegui il debug del file attivo",
+    "c_cpp.command.logDiagnostics.title": "Registra Diagnostica"
+}

Extension/package.nls.json

@@ -0,0 +1,22 @@
+{
+    "c_cpp.command.configurationSelect.title": "Select a configuration...",
+    "c_cpp.command.configurationProviderSelect.title": "Change configuration provider...",
+    "c_cpp.command.configurationEditJSON.title": "Edit configurations (JSON)",
+    "c_cpp.command.configurationEditUI.title": "Edit configurations (UI)",
+    "c_cpp.command.goToDeclaration.title": "Go to Declaration",
+    "c_cpp.command.peekDeclaration.title": "Peek Declaration",
+    "c_cpp.command.switchHeaderSource.title": "Switch Header/Source",
+    "c_cpp.command.navigate.title": "Navigate...",
+    "c_cpp.command.enableErrorSquiggles.title": "Enable error squiggles",
+    "c_cpp.command.disableErrorSquiggles.title": "Disable error squiggles",
+    "c_cpp.command.toggleIncludeFallback.title": "Toggle IntelliSense engine fallback on include errors",
+    "c_cpp.command.toggleDimInactiveRegions.title": "Toggle inactive region colorization",
+    "c_cpp.command.showReleaseNotes.title": "Show release notes",
+    "c_cpp.command.resetDatabase.title": "Reset IntelliSense database",
+    "c_cpp.command.pauseParsing.title": "Pause parsing",
+    "c_cpp.command.resumeParsing.title": "Resume parsing",
+    "c_cpp.command.showParsingCommands.title": "Show parsing commands",
+    "c_cpp.command.takeSurvey.title": "Take survey",
+    "c_cpp.command.buildAndDebugActiveFile.title": "Build and Debug Active File",
+    "c_cpp.command.logDiagnostics.title": "Log Diagnostics"
+}

Extension/package.nls.zh-cn.json

@@ -0,0 +1,22 @@
+{
+    "c_cpp.command.configurationSelect.title": "选择配置...",
+    "c_cpp.command.configurationProviderSelect.title": "更换配置提供程序...",
+    "c_cpp.command.configurationEditJSON.title": "编辑配置 (JSON)",
+    "c_cpp.command.configurationEditUI.title": "编辑配置 (UI)",
+    "c_cpp.command.goToDeclaration.title": "跳转到声明",
+    "c_cpp.command.peekDeclaration.title": "查看声明",
+    "c_cpp.command.switchHeaderSource.title": "切换头文件/源文件",
+    "c_cpp.command.navigate.title": "导航...",
+    "c_cpp.command.enableErrorSquiggles.title": "启用错误下划线",
+    "c_cpp.command.disableErrorSquiggles.title": "禁用错误下划线",
+    "c_cpp.command.toggleIncludeFallback.title": "切换IntelliSense引擎头文件包含错误回退",
+    "c_cpp.command.toggleDimInactiveRegions.title": "切换非活跃区域着色",
+    "c_cpp.command.showReleaseNotes.title": "查看版本说明",
+    "c_cpp.command.resetDatabase.title": "重置IntelliSense数据",
+    "c_cpp.command.pauseParsing.title": "暂停解析",
+    "c_cpp.command.resumeParsing.title": "继续解析",
+    "c_cpp.command.showParsingCommands.title": "查看解析命令",
+    "c_cpp.command.takeSurvey.title": "调查问卷",
+    "c_cpp.command.buildAndDebugActiveFile.title": "生成和调试当前文件",
+    "c_cpp.command.logDiagnostics.title": "记录诊断"
+}

Extension/src/Debugger/ParsedEnvironmentFile.ts

@@ -0,0 +1,85 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as fs from 'fs';
+
+export interface Environment { 
+    name: string;
+    value: string;
+}
+
+export class ParsedEnvironmentFile {
+    public Env: Environment[];
+    public Warning: string | null;
+
+    private constructor(env: Environment[], warning: string | null) {
+        this.Env = env;
+        this.Warning = warning;
+    }
+
+    public static CreateFromFile(envFile: string, initialEnv: Environment[] | undefined): ParsedEnvironmentFile {
+        let content: string = fs.readFileSync(envFile, "utf8");
+        return this.CreateFromContent(content, envFile, initialEnv);
+    }
+
+    public static CreateFromContent(content: string, envFile: string, initialEnv: Environment[] | undefined): ParsedEnvironmentFile {
+
+        // Remove UTF-8 BOM if present
+        if (content.charAt(0) === '\uFEFF') {
+            content = content.substr(1);
+        }
+
+        let parseErrors: string[] = [];
+        let env: Map<string, any> = new Map();
+
+        if (initialEnv) {
+            // Convert array to map to prevent duplicate keys being created.
+            // If a duplicate key is found, replace it.
+            initialEnv.forEach((e) => {
+                env.set(e.name, e.value);
+            });
+        }
+
+        content.split("\n").forEach(line => {
+            // Split the line between key and value
+            const r: RegExpMatchArray = line.match(/^\s*([\w\.\-]+)\s*=\s*(.*)?\s*$/);
+
+            if (r !== null) {
+                const key: string = r[1];
+                let value: string = r[2] || "";
+                if ((value.length > 0) && (value.charAt(0) === '"') && (value.charAt(value.length - 1) === '"')) {
+                    value = value.replace(/\\n/gm, "\n");
+                }
+
+                value = value.replace(/(^['"]|['"]$)/g, "");
+
+                env.set(key, value);
+            } else {
+                // Blank lines and lines starting with # are no parse errors
+                const comments: RegExp = new RegExp(/^\s*(#|$)/);
+                if (!comments.test(line)) {
+                    parseErrors.push(line);
+                }
+            }
+        });
+
+        // show error message if single lines cannot get parsed
+        let warning: string = null;
+        if (parseErrors.length !== 0) {
+            warning = "Ignoring non-parseable lines in envFile " + envFile + ": ";
+            parseErrors.forEach(function (value, idx, array): void {
+                warning += "\"" + value + "\"" + ((idx !== array.length - 1) ? ", " : ".");
+            });
+        }
+
+        // Convert env map back to array.
+        const arrayEnv: Environment[] = [];
+        for (let key of env.keys()) {
+            arrayEnv.push({name: key, value: env.get(key)});
+        }
+
+        return new ParsedEnvironmentFile(arrayEnv, warning);
+    }
+}

Extension/src/Debugger/attachQuickPick.ts

@@ -0,0 +1,70 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All Rights Reserved.
+ * See 'LICENSE' in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import * as util from '../common';
+import * as vscode from 'vscode';
+
+class RefreshButton implements vscode.QuickInputButton {
+    get iconPath(): { dark: vscode.Uri; light: vscode.Uri } {
+        const refreshImagePathDark: string = util.getExtensionFilePath("assets/Refresh_inverse.svg");
+        const refreshImagePathLight: string = util.getExtensionFilePath("assets/Refresh.svg");
+
+        return {
+            dark: vscode.Uri.file(refreshImagePathDark),
+            light: vscode.Uri.file(refreshImagePathLight)
+        };
+    }
+
+    get tooltip(): string {
+        return "Refresh process list";
+    }
+}
+
+export interface AttachItem extends vscode.QuickPickItem {
+    id: string;
+}
+
+export function showQuickPick(getAttachItems: () => Promise<AttachItem[]>): Promise<string> {
+    return getAttachItems().then(processEntries => {
+        return new Promise<string>((resolve, reject) => {
+            let quickPick: vscode.QuickPick<AttachItem> = vscode.window.createQuickPick<AttachItem>();
+            quickPick.title = "Attach to process";
+            quickPick.canSelectMany = false;
+            quickPick.matchOnDescription = true;
+            quickPick.matchOnDetail = true;
+            quickPick.placeholder = "Select the process to attach to";
+            quickPick.items = processEntries;
+            quickPick.buttons = [new RefreshButton()];
+
+            let disposables: vscode.Disposable[] = [];
+
+            quickPick.onDidTriggerButton(button => {
+                getAttachItems().then(processEntries => quickPick.items = processEntries);
+            }, undefined, disposables);
+
+            quickPick.onDidAccept(() => {
+                if (quickPick.selectedItems.length !== 1) {
+                    reject(new Error("Process not selected"));
+                }
+
+                let selectedId: string = quickPick.selectedItems[0].id;
+
+                disposables.forEach(item => item.dispose());
+                quickPick.dispose();
+
+                resolve(selectedId);
+            }, undefined, disposables);
+
+            quickPick.onDidHide(() => {
+                disposables.forEach(item => item.dispose());
+                quickPick.dispose();
+
+                reject(new Error("Process not selected."));
+            }, undefined, disposables);
+
+            quickPick.show();
+        });
+    });
+}

Extension/src/Debugger/attachToProcess.ts

@@ -5,6 +5,7 @@
 
 import { execChildProcess } from '../common';
 import { PsProcessParser } from './nativeAttach';
+import { AttachItem, showQuickPick } from './attachQuickPick';
 
 import * as debugUtils from './utils';
 import * as fs from 'fs';
@@ -13,10 +14,6 @@ import * as path from 'path';
 import * as util from '../common';
 import * as vscode from 'vscode';
 
-export interface AttachItem extends vscode.QuickPickItem {
-    id: string;
-}
-
 export interface AttachItemsProvider {
     getAttachItems(): Promise<AttachItem[]>;
 }
@@ -29,19 +26,7 @@ export class AttachPicker {
             if (!ready) {
                 util.displayExtensionNotReadyPrompt();
             } else {
-                return this.attachItemsProvider.getAttachItems()
-                    .then(processEntries => {
-                        let attachPickOptions: vscode.QuickPickOptions = {
-                            matchOnDescription: true,
-                            matchOnDetail: true,
-                            placeHolder: "Select the process to attach to"
-                        };
-
-                        return vscode.window.showQuickPick(processEntries, attachPickOptions)
-                            .then(chosenProcess => {
-                                return chosenProcess ? chosenProcess.id : Promise.reject<string>(new Error("Process not selected."));
-                            });
-                    });
+                return showQuickPick(() => this.attachItemsProvider.getAttachItems());
             }
         });
     }
@@ -74,7 +59,7 @@ export class RemoteAttachPicker {
                     !fs.existsSync(pipeTransport.pipeProgram)) {
                     const pipeProgramStr: string = pipeTransport.pipeProgram.toLowerCase().trim();
                     const expectedArch: debugUtils.ArchType = debugUtils.ArchType[process.arch];
-                    
+
                     // Check for pipeProgram
                     if (!fs.existsSync(config.pipeTransport.pipeProgram)) {
                         pipeProgram = debugUtils.ArchitectureReplacer.checkAndReplaceWSLPipeProgram(pipeProgramStr, expectedArch);
@@ -84,7 +69,7 @@ export class RemoteAttachPicker {
                     if (!pipeProgram && config.pipeTransport.pipeCwd) {
                         const pipeCwdStr: string = config.pipeTransport.pipeCwd.toLowerCase().trim();
                         const newPipeProgramStr: string = path.join(pipeCwdStr, pipeProgramStr);
-                        
+
                         if (!fs.existsSync(newPipeProgramStr)) {
                             pipeProgram = debugUtils.ArchitectureReplacer.checkAndReplaceWSLPipeProgram(newPipeProgramStr, expectedArch);
                         }
@@ -120,9 +105,10 @@ export class RemoteAttachPicker {
 
     private getRemoteOSAndProcesses(pipeCmd: string): Promise<AttachItem[]> {
         // Commands to get OS and processes
-        const command: string = `sh -c 'uname && if [ $(uname) = "Linux" ] ; then ${PsProcessParser.psLinuxCommand} ; elif [ $(uname) = "Darwin" ] ; ` +
-            `then ${PsProcessParser.psDarwinCommand}; fi'`;
+        const command: string = `sh -c "uname && if [ $(uname) = \\\"Linux\\\" ] ; then ${PsProcessParser.psLinuxCommand} ; elif [ $(uname) = \\\"Darwin\\\" ] ; ` +
+            `then ${PsProcessParser.psDarwinCommand}; fi"`;
 
+        // Must use single quotes around ${command}. Linux systems evaluate $() within double-quotes.
         return execChildProcess(`${pipeCmd} '${command}'`, null, this._channel).then(output => {
             // OS will be on first line
             // Processess will follow if listed

Extension/src/Debugger/configurationProvider.ts

@@ -7,11 +7,82 @@ import * as debugUtils from './utils';
 import * as os from 'os';
 import * as path from 'path';
 import * as vscode from 'vscode';
+import { getBuildTasks, BuildTaskDefinition } from '../LanguageServer/extension';
+import * as util from '../common';
+import * as fs from 'fs';
+import * as Telemetry from '../telemetry';
+import { buildAndDebugActiveFileStr } from './extension';
 
 import { IConfiguration, IConfigurationSnippet, DebuggerType, MIConfigurations, WindowsConfigurations, WSLConfigurations, PipeTransportConfigurations } from './configurations';
 import { parse } from 'jsonc-parser';
+import { PlatformInformation } from '../platform';
+import { Environment, ParsedEnvironmentFile } from './ParsedEnvironmentFile';
 
-abstract class CppConfigurationProvider implements vscode.DebugConfigurationProvider {
+function isDebugLaunchStr(str: string): boolean {
+    return str === "(gdb) Launch" || str === "(lldb) Launch" || str === "(Windows) Launch";
+}
+
+/*
+ * Retrieves configurations from a provider and displays them in a quickpick menu to be selected.
+ * Ensures that the selected configuration's preLaunchTask (if existent) is populated in the user's task.json.
+ * Automatically starts debugging for "Build and Debug" configurations.
+ */
+export class QuickPickConfigurationProvider implements vscode.DebugConfigurationProvider {
+    private underlyingProvider: vscode.DebugConfigurationProvider;
+
+    public constructor(provider: CppConfigurationProvider) {
+        this.underlyingProvider = provider;
+    }
+
+    async provideDebugConfigurations(folder: vscode.WorkspaceFolder | undefined, token?: vscode.CancellationToken): Promise<vscode.DebugConfiguration[]> {
+        const configs: vscode.DebugConfiguration[] = await this.underlyingProvider.provideDebugConfigurations(folder, token);
+        const defaultConfig: vscode.DebugConfiguration = configs.find(config => { return isDebugLaunchStr(config.name); });
+        console.assert(defaultConfig);
+        const editor: vscode.TextEditor = vscode.window.activeTextEditor;
+        if (!editor || !util.fileIsCOrCppSource(editor.document.fileName) || configs.length <= 1) {
+            return [defaultConfig];
+        }
+        interface MenuItem extends vscode.QuickPickItem {
+            configuration: vscode.DebugConfiguration;
+        }
+
+        const items: MenuItem[] = configs.map<MenuItem>(config => {
+            let menuItem: MenuItem = {label: config.name, configuration: config};
+            // Rename the menu item for the default configuration as its name is non-descriptive.
+            if (isDebugLaunchStr(menuItem.label)) {
+                menuItem.label = "Default Configuration";
+            }
+            return menuItem;
+        });
+
+        const selection: MenuItem = await vscode.window.showQuickPick(items, {placeHolder: "Select a configuration"});
+        if (!selection) {
+            throw new Error(); // User canceled it.
+        }
+        if (selection.label.startsWith("cl.exe")) {
+            if (!process.env.DevEnvDir || process.env.DevEnvDir.length === 0) {
+                vscode.window.showErrorMessage('cl.exe build and debug is only usable when VS Code is run from the Developer Command Prompt for VS.');
+                throw new Error();
+            }
+        }
+        if (selection.label.indexOf(buildAndDebugActiveFileStr()) !== -1 && selection.configuration.preLaunchTask) {
+            try {
+                await util.ensureBuildTaskExists(selection.configuration.preLaunchTask);
+                await vscode.debug.startDebugging(folder, selection.configuration);
+                Telemetry.logDebuggerEvent("buildAndDebug", { "success": "true" });
+            } catch (e) {
+                Telemetry.logDebuggerEvent("buildAndDebug", { "success": "false" });
+            }
+        }
+        return [selection.configuration];
+    }
+
+    resolveDebugConfiguration(folder: vscode.WorkspaceFolder | undefined, config: vscode.DebugConfiguration, token?: vscode.CancellationToken): vscode.ProviderResult<vscode.DebugConfiguration> {
+        return this.underlyingProvider.resolveDebugConfiguration(folder, config, token);
+    }
+}
+
+class CppConfigurationProvider implements vscode.DebugConfigurationProvider {
     private type: DebuggerType;
     private provider: IConfigurationAssetProvider;
 
@@ -23,8 +94,85 @@ abstract class CppConfigurationProvider implements vscode.DebugConfigurationProv
     /**
 	 * Returns a list of initial debug configurations based on contextual information, e.g. package.json or folder.
 	 */
-    provideDebugConfigurations(folder: vscode.WorkspaceFolder | undefined, token?: vscode.CancellationToken): vscode.ProviderResult<vscode.DebugConfiguration[]> {
-        return this.provider.getInitialConfigurations(this.type);
+    async provideDebugConfigurations(folder: vscode.WorkspaceFolder | undefined, token?: vscode.CancellationToken): Promise<vscode.DebugConfiguration[]> {
+        let buildTasks: vscode.Task[] = await getBuildTasks(true); 
+        if (buildTasks.length === 0) {
+            return Promise.resolve(this.provider.getInitialConfigurations(this.type));
+        }
+        const defaultConfig: vscode.DebugConfiguration = this.provider.getInitialConfigurations(this.type).find(config => {
+            return isDebugLaunchStr(config.name);
+        });
+        console.assert(defaultConfig, "Could not find default debug configuration.");
+
+        const platformInfo: PlatformInformation = await PlatformInformation.GetPlatformInformation();
+        const platform: string = platformInfo.platform;
+
+        // Filter out build tasks that don't match the currently selectede debug configuration type.
+        buildTasks = buildTasks.filter((task: vscode.Task) => {
+            if (defaultConfig.name === "(Windows) Launch") {
+                if (task.name.startsWith("cl.exe")) {
+                    return true;
+                }
+            } else {
+                if (!task.name.startsWith("cl.exe")) {
+                    return true;
+                }
+            }
+            return false;
+        });
+
+        // Generate new configurations for each build task.
+        // Generating a task is async, therefore we must *await* *all* map(task => config) Promises to resolve.
+        let configs: vscode.DebugConfiguration[] = await Promise.all(buildTasks.map<Promise<vscode.DebugConfiguration>>(async task => {
+            const definition: BuildTaskDefinition = task.definition as BuildTaskDefinition;
+            const compilerName: string = path.basename(definition.compilerPath);
+
+            let newConfig: vscode.DebugConfiguration = Object.assign({}, defaultConfig); // Copy enumerables and properties
+
+            newConfig.name = compilerName + buildAndDebugActiveFileStr();
+            newConfig.preLaunchTask = task.name;
+            newConfig.externalConsole = false;
+            const exeName: string = path.join("${fileDirname}", "${fileBasenameNoExtension}");
+            newConfig.program = platform === "win32" ? exeName + ".exe" : exeName;
+
+            return new Promise<vscode.DebugConfiguration>(resolve => {
+                if (platform === "darwin") {
+                    return resolve(newConfig);
+                } else {
+                    let debuggerName: string;
+                    if (compilerName.startsWith("clang")) {
+                        newConfig.MIMode = "lldb";
+                        const suffixIndex: number = compilerName.indexOf("-");
+                        const suffix: string = suffixIndex === -1 ? "" : compilerName.substr(suffixIndex);
+                        debuggerName = "lldb-mi" + suffix;
+                    } else if (compilerName === "cl.exe") {
+                        newConfig.miDebuggerPath = undefined;
+                        newConfig.type = "cppvsdbg";
+                        return resolve(newConfig);
+                    } else {
+                        debuggerName = "gdb";
+                    }
+        
+                    if (platform === "win32") {
+                        debuggerName += ".exe";
+                    }
+        
+                    const compilerDirname: string = path.dirname(definition.compilerPath);
+                    const debuggerPath: string = path.join(compilerDirname, debuggerName);
+                    fs.stat(debuggerPath, (err, stats: fs.Stats) => {
+                        if (!err && stats && stats.isFile) {
+                            newConfig.miDebuggerPath = debuggerPath;
+                        } else {
+                            // TODO should probably resolve a missing debugger in a more graceful fashion for win32.
+                            newConfig.miDebuggerPath = path.join("/usr", "bin", debuggerName);
+                        }
+                        return resolve(newConfig);
+                    });
+                }
+            });
+        }));
+        configs.push(defaultConfig);
+        return configs;
     }
 
     /**
@@ -32,10 +180,41 @@ abstract class CppConfigurationProvider implements vscode.DebugConfigurationProv
 	 */
     resolveDebugConfiguration(folder: vscode.WorkspaceFolder | undefined, config: vscode.DebugConfiguration, token?: vscode.CancellationToken): vscode.ProviderResult<vscode.DebugConfiguration> {
         if (config) {
-            // Fail if cppvsdbg type is running on non-Windows
-            if (config.type === 'cppvsdbg' && os.platform() !== 'win32') {
-                vscode.window.showErrorMessage("Debugger of type: 'cppvsdbg' is only available on Windows. Use type: 'cppdbg' on the current OS platform.");
-                return undefined;
+            if (config.type === 'cppvsdbg') {
+                // Fail if cppvsdbg type is running on non-Windows
+                if (os.platform() !== 'win32') {
+                    vscode.window.showErrorMessage("Debugger of type: 'cppvsdbg' is only available on Windows. Use type: 'cppdbg' on the current OS platform.");
+                    return undefined;
+                }
+
+                // Disable debug heap by default, enable if 'enableDebugHeap' is set.
+                if (!config.enableDebugHeap) {
+                    const disableDebugHeapEnvSetting : Environment = {"name" : "_NO_DEBUG_HEAP", "value" : "1"};
+
+                    if (config.environment && util.isArray(config.environment)) {
+                        config.environment.push(disableDebugHeapEnvSetting);
+                    } else {
+                        config.environment = [disableDebugHeapEnvSetting];
+                    }
+                }
+
+                // Add environment variables from .env file
+                if (config.envFile) {
+                    try {
+                        const parsedFile: ParsedEnvironmentFile = ParsedEnvironmentFile.CreateFromFile(config.envFile.replace(/\${workspaceFolder}/g, folder.uri.path), config["environment"]);
+                        
+                        // show error message if single lines cannot get parsed
+                        if (parsedFile.Warning) {
+                            CppConfigurationProvider.showFileWarningAsync(parsedFile.Warning, config.envFile);
+                        }
+
+                        config.environment = parsedFile.Env;
+
+                        delete config.envFile;
+                    } catch (e) {
+                        throw new Error("Can't parse envFile " + config.envFile);
+                    }
+                }
             }
 
             // Modify WSL config for OpenDebugAD7
@@ -64,6 +243,17 @@ abstract class CppConfigurationProvider implements vscode.DebugConfigurationProv
         // if config or type is not specified, return null to trigger VS Code to open a configuration file https://github.com/Microsoft/vscode/issues/54213 
         return config && config.type ? config : null;
     }
+
+    private static async showFileWarningAsync(message: string, fileName: string) : Promise<void> {
+        const openItem: vscode.MessageItem = { title: 'Open envFile' };
+        let result: vscode.MessageItem = await vscode.window.showWarningMessage(message, openItem);
+        if (result && result.title === openItem.title) {
+            let doc: vscode.TextDocument = await vscode.workspace.openTextDocument(fileName);
+            if (doc) {
+                vscode.window.showTextDocument(doc);
+            }
+        }
+    }
 }
 
 export class CppVsDbgConfigurationProvider extends CppConfigurationProvider {

Extension/src/Debugger/debugAdapterDescriptorFactory.ts

@@ -0,0 +1,74 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All Rights Reserved.
+ * See 'LICENSE' in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import * as vscode from "vscode";
+import * as util from '../common';
+import * as path from 'path';
+import * as os from 'os';
+
+// Registers DebugAdapterDescriptorFactory for `cppdbg` and `cppvsdbg`. If it is not ready, it will prompt a wait for the download dialog.
+// NOTE: This file is not automatically tested.
+
+abstract class AbstractDebugAdapterDescriptorFactory implements vscode.DebugAdapterDescriptorFactory {
+    protected readonly context: vscode.ExtensionContext;
+
+    // This is important for the Mock Debugger since it can not use src/common
+    constructor(context: vscode.ExtensionContext) {
+        this.context = context;
+    }
+
+    abstract createDebugAdapterDescriptor(session: vscode.DebugSession, executable: vscode.DebugAdapterExecutable | undefined): vscode.ProviderResult<vscode.DebugAdapterDescriptor>;
+}
+
+export class CppdbgDebugAdapterDescriptorFactory extends AbstractDebugAdapterDescriptorFactory {
+    public static DEBUG_TYPE : string = "cppdbg";
+
+    constructor(context: vscode.ExtensionContext) {
+        super(context);
+    }
+
+    createDebugAdapterDescriptor(session: vscode.DebugSession, executable: vscode.DebugAdapterExecutable | undefined): vscode.ProviderResult<vscode.DebugAdapterDescriptor> {
+        return util.isExtensionReady().then(ready => {
+            if (ready) {
+                let command: string = path.join(this.context.extensionPath, './debugAdapters/OpenDebugAD7');
+
+                // Windows has the exe in debugAdapters/bin.
+                if (os.platform() === 'win32') {
+                    command = path.join(this.context.extensionPath, "./debugAdapters/bin/OpenDebugAD7.exe");
+                }
+
+                return new vscode.DebugAdapterExecutable(command, []);
+            } else {
+                throw new Error(util.extensionNotReadyString);
+            }
+        });
+    }
+}
+
+export class CppvsdbgDebugAdapterDescriptorFactory extends AbstractDebugAdapterDescriptorFactory {
+    public static DEBUG_TYPE : string = "cppvsdbg";
+
+    constructor(context: vscode.ExtensionContext) {
+        super(context);
+    }
+
+    createDebugAdapterDescriptor(session: vscode.DebugSession, executable: vscode.DebugAdapterExecutable | undefined): vscode.ProviderResult<vscode.DebugAdapterDescriptor> {
+        if (os.platform() !== 'win32') {
+            vscode.window.showErrorMessage("Debugger type 'cppvsdbg' is not avaliable for non-Windows machines.");
+            return null;
+        } else {
+            return util.isExtensionReady().then(ready => {
+                if (ready) {
+                    return new vscode.DebugAdapterExecutable(
+                        path.join(this.context.extensionPath, './debugAdapters/vsdbg/bin/vsdbg.exe'),
+                        ['--interpreter=vscode']
+                    );
+                } else {
+                    throw new Error(util.extensionNotReadyString);
+                }
+            });
+        }
+    }
+}

Extension/src/Debugger/extension.ts

@@ -7,14 +7,19 @@ import * as vscode from 'vscode';
 import * as os from 'os';
 import { AttachPicker, RemoteAttachPicker, AttachItemsProvider } from './attachToProcess';
 import { NativeAttachItemsProviderFactory } from './nativeAttach';
-import { ConfigurationAssetProviderFactory, CppVsDbgConfigurationProvider, CppDbgConfigurationProvider, ConfigurationSnippetProvider, IConfigurationAssetProvider } from './configurationProvider';
+import { QuickPickConfigurationProvider, ConfigurationAssetProviderFactory, CppVsDbgConfigurationProvider, CppDbgConfigurationProvider, ConfigurationSnippetProvider, IConfigurationAssetProvider } from './configurationProvider';
+import { CppdbgDebugAdapterDescriptorFactory, CppvsdbgDebugAdapterDescriptorFactory } from './debugAdapterDescriptorFactory';
 import * as util from '../common';
-import * as path from 'path';
+import * as Telemetry from '../telemetry';
 
 // The extension deactivate method is asynchronous, so we handle the disposables ourselves instead of using extensonContext.subscriptions.
 let disposables: vscode.Disposable[] = [];
 
-export function initialize(): void {
+export function buildAndDebugActiveFileStr(): string {
+    return " build and debug active file";
+}
+
+export function initialize(context: vscode.ExtensionContext): void {
     // Activate Process Picker Commands
     let attachItemsProvider: AttachItemsProvider = NativeAttachItemsProviderFactory.Get();
     let attacher: AttachPicker = new AttachPicker(attachItemsProvider);
@@ -26,10 +31,94 @@ export function initialize(): void {
     let configurationProvider: IConfigurationAssetProvider = ConfigurationAssetProviderFactory.getConfigurationProvider();
     // On non-windows platforms, the cppvsdbg debugger will not be registered for initial configurations.
     // This will cause it to not show up on the dropdown list.
+    let vsdbgProvider: CppVsDbgConfigurationProvider = null;
     if (os.platform() === 'win32') {
-        disposables.push(vscode.debug.registerDebugConfigurationProvider('cppvsdbg', new CppVsDbgConfigurationProvider(configurationProvider)));
+        vsdbgProvider = new CppVsDbgConfigurationProvider(configurationProvider);
+        disposables.push(vscode.debug.registerDebugConfigurationProvider('cppvsdbg', new QuickPickConfigurationProvider(vsdbgProvider)));
     }
-    disposables.push(vscode.debug.registerDebugConfigurationProvider('cppdbg', new CppDbgConfigurationProvider(configurationProvider)));
+    const provider: CppDbgConfigurationProvider = new CppDbgConfigurationProvider(configurationProvider);
+    disposables.push(vscode.debug.registerDebugConfigurationProvider('cppdbg', new QuickPickConfigurationProvider(provider)));
+
+    disposables.push(vscode.commands.registerTextEditorCommand("C_Cpp.BuildAndDebugActiveFile", async (textEditor: vscode.TextEditor, edit: vscode.TextEditorEdit, ...args: any[]) => {
+        const folder: vscode.WorkspaceFolder = vscode.workspace.getWorkspaceFolder(textEditor.document.uri);
+        if (!folder) {
+            // Not enabled because we do not react to single-file mode correctly yet.
+            // We get an ENOENT when the user's c_cpp_properties.json is attempted to be parsed.
+            // The DefaultClient will also have its configuration accessed, but since it doesn't exist it errors out.
+            vscode.window.showErrorMessage('This command is not yet available for single-file mode.');
+            return Promise.resolve();
+        }
+
+        if (!util.fileIsCOrCppSource(textEditor.document.uri.fsPath)) {
+            vscode.window.showErrorMessage('Cannot build and debug because the active file is not a C or C++ source file.');
+            return Promise.resolve();
+        }
+        
+        let configs: vscode.DebugConfiguration[] = (await provider.provideDebugConfigurations(folder)).filter(config => {
+            return config.name.indexOf(buildAndDebugActiveFileStr()) !== -1;
+        });
+
+        if (vsdbgProvider) {
+            let vsdbgConfigs: vscode.DebugConfiguration[] = (await vsdbgProvider.provideDebugConfigurations(folder)).filter(config => {
+                return config.name.indexOf(buildAndDebugActiveFileStr()) !== -1;
+            });
+            if (vsdbgConfigs) {
+                configs.push(...vsdbgConfigs);
+            }
+        }
+
+        interface MenuItem extends vscode.QuickPickItem {
+            configuration: vscode.DebugConfiguration;
+        }
+
+        const items: MenuItem[] = configs.map<MenuItem>(config => {
+            return {label: config.name, configuration: config};
+        });
+
+        vscode.window.showQuickPick(items, {placeHolder: (items.length === 0 ? "No compiler found" : "Select a compiler" )}).then(async selection => {
+            if (!selection) {
+                return; // User canceled it.
+            }
+            if (selection.label.startsWith("cl.exe")) {
+                if (!process.env.DevEnvDir || process.env.DevEnvDir.length === 0) {
+                    vscode.window.showErrorMessage('cl.exe build and debug is only usable when VS Code is run from the Developer Command Prompt for VS.');
+                    return;
+                }
+            }
+            if (selection.configuration.preLaunchTask) {
+                if (folder) {
+                    try {
+                        await util.ensureBuildTaskExists(selection.configuration.preLaunchTask);
+                        Telemetry.logDebuggerEvent("buildAndDebug", { "success": "false" });
+                    } catch (e) {
+                        if (e && e.message === util.failedToParseTasksJson) {
+                            vscode.window.showErrorMessage(util.failedToParseTasksJson);
+                        }
+                        return Promise.resolve();
+                    }
+                } else {
+                    return Promise.resolve();
+                    // TODO uncomment this when single file mode works correctly.
+                    // const buildTasks: vscode.Task[] = await getBuildTasks(true);
+                    // const task: vscode.Task = buildTasks.find(task => task.name === selection.configuration.preLaunchTask);
+                    // await vscode.tasks.executeTask(task);
+                    // delete selection.configuration.preLaunchTask;
+                }
+            }
+
+            // Attempt to use the user's (possibly) modified configuration before using the generated one.
+            try {
+                await vscode.debug.startDebugging(folder, selection.configuration.name);
+                Telemetry.logDebuggerEvent("buildAndDebug", { "success": "true" });
+            } catch (e) {
+                try {
+                    vscode.debug.startDebugging(folder, selection.configuration);
+                } catch (e) {
+                    Telemetry.logDebuggerEvent("buildAndDebug", { "success": "false" });
+                }
+            }
+        });
+    }));
 
     configurationProvider.getConfigurationSnippets();
 
@@ -38,57 +127,17 @@ export function initialize(): void {
         language: 'jsonc',
         pattern: '**/launch.json'
     }];
+
     // ConfigurationSnippetProvider needs to be initiallized after configurationProvider calls getConfigurationSnippets.
     disposables.push(vscode.languages.registerCompletionItemProvider(launchJsonDocumentSelector, new ConfigurationSnippetProvider(configurationProvider)));
 
-    // Activate Adapter Commands 
-    registerAdapterExecutableCommands();
+    // Register Debug Adapters
+    disposables.push(vscode.debug.registerDebugAdapterDescriptorFactory(CppvsdbgDebugAdapterDescriptorFactory.DEBUG_TYPE, new CppvsdbgDebugAdapterDescriptorFactory(context)));
+    disposables.push(vscode.debug.registerDebugAdapterDescriptorFactory(CppdbgDebugAdapterDescriptorFactory.DEBUG_TYPE, new CppdbgDebugAdapterDescriptorFactory(context)));
 
     vscode.Disposable.from(...disposables);
 }
 
 export function dispose(): void {
     disposables.forEach(d => d.dispose());
-}
-
-// Registers adapterExecutableCommands for cppdbg and cppvsdbg. If it is not ready, it will prompt waiting for the download.
-// 
-// Note: util.extensionContext.extensionPath is needed for the commands because VsCode does not support relative paths for adapterExecutableComand
-function registerAdapterExecutableCommands(): void {
-    disposables.push(vscode.commands.registerCommand('extension.cppdbgAdapterExecutableCommand', () => {
-        return util.isExtensionReady().then(ready => {
-            if (ready) {
-                let command: string = path.join(util.extensionContext.extensionPath, './debugAdapters/OpenDebugAD7');
-
-                // Windows has the exe in debugAdapters/bin.
-                if (os.platform() === 'win32') {
-                    command = path.join(util.extensionContext.extensionPath, "./debugAdapters/bin/OpenDebugAD7.exe");
-                }
-
-                return {
-                    command: command
-                };
-            } else {
-                throw new Error(util.extensionNotReadyString);
-            }
-        });
-    }));
-
-    disposables.push(vscode.commands.registerCommand('extension.cppvsdbgAdapterExecutableCommand', () => {
-        if (os.platform() !== 'win32') {
-            vscode.window.showErrorMessage("Debugger type 'cppvsdbg' is not avaliable for non-Windows machines.");
-            return null;
-        } else {
-            return util.isExtensionReady().then(ready => {
-                if (ready) {
-                    return {
-                        command: path.join(util.extensionContext.extensionPath, './debugAdapters/vsdbg/bin/vsdbg.exe'),
-                        args: ['--interpreter=vscode']
-                    };
-                } else {
-                    throw new Error(util.extensionNotReadyString);
-                }
-            });
-        }
-    }));
-}
+}

Extension/src/Debugger/nativeAttach.ts

@@ -5,7 +5,8 @@
 
 import * as child_process from 'child_process';
 import * as os from 'os';
-import { AttachItem, AttachItemsProvider } from './attachToProcess';
+import { AttachItemsProvider } from './attachToProcess';
+import { AttachItem } from './attachQuickPick';
 
 class Process {
     constructor(public name: string, public pid: string, public commandLine: string) { }

Extension/src/LanguageServer/client.ts

@@ -23,12 +23,14 @@ import { createProtocolFilter } from './protocolFilter';
 import { DataBinding } from './dataBinding';
 import minimatch = require("minimatch");
 import * as logger from '../logger';
-import { updateLanguageConfigurations } from './extension';
+import { updateLanguageConfigurations, registerCommands } from './extension';
 import { CancellationTokenSource } from 'vscode';
 import { SettingsTracker, getTracker } from './settingsTracker';
 import { getTestHook, TestHook } from '../testHook';
 import { getCustomConfigProviders, CustomConfigurationProviderCollection, CustomConfigurationProvider1 } from '../LanguageServer/customProviders';
 import { ABTestSettings, getABTestSettings } from '../abTesting';
+import * as fs from 'fs';
+import * as os from 'os';
 
 let ui: UI;
 const configProviderTimeout: number = 2000;
@@ -111,11 +113,44 @@ interface CompileCommandsPaths {
     paths: string[];
 }
 
+interface QueryTranslationUnitSourceParams {
+    uri: string;
+}
+
+export enum QueryTranslationUnitSourceConfigDisposition {
+
+    /**
+     * No custom config needed for this file
+     */
+    ConfigNotNeeded = 0,
+
+    /**
+     * Custom config is needed for this file
+     */
+    ConfigNeeded = 1,
+
+    /**
+     * Custom config is needed for the ancestor file returned in uri
+     */
+    AncestorConfigNeeded = 2
+}
+
+interface QueryTranslationUnitSourceResult {
+    uri: string;
+    configDisposition: QueryTranslationUnitSourceConfigDisposition;
+}
+
+interface GetDiagnosticsResult {
+    diagnostics: string;
+}
+
 // Requests
 const NavigationListRequest: RequestType<TextDocumentIdentifier, string, void, void> = new RequestType<TextDocumentIdentifier, string, void, void>('cpptools/requestNavigationList');
 const GoToDeclarationRequest: RequestType<void, void, void, void> = new RequestType<void, void, void, void>('cpptools/goToDeclaration');
 const QueryCompilerDefaultsRequest: RequestType<QueryCompilerDefaultsParams, configs.CompilerDefaults, void, void> = new RequestType<QueryCompilerDefaultsParams, configs.CompilerDefaults, void, void>('cpptools/queryCompilerDefaults');
+const QueryTranslationUnitSourceRequest: RequestType<QueryTranslationUnitSourceParams, QueryTranslationUnitSourceResult, void, void> = new RequestType<QueryTranslationUnitSourceParams, QueryTranslationUnitSourceResult, void, void>('cpptools/queryTranslationUnitSource');
 const SwitchHeaderSourceRequest: RequestType<SwitchHeaderSourceParams, string, void, void> = new RequestType<SwitchHeaderSourceParams, string, void, void>('cpptools/didSwitchHeaderSource');
+const GetDiagnosticsRequest: RequestType<void, GetDiagnosticsResult, void, void> = new RequestType<void, GetDiagnosticsResult, void, void>('cpptools/getDiagnostics');
 
 // Notifications to the server
 const DidOpenNotification: NotificationType<DidOpenTextDocumentParams, void> = new NotificationType<DidOpenTextDocumentParams, void>('textDocument/didOpen');
@@ -145,6 +180,7 @@ const DebugLogNotification:  NotificationType<OutputNotificationBody, void> = ne
 const InactiveRegionNotification:  NotificationType<InactiveRegionParams, void> = new NotificationType<InactiveRegionParams, void>('cpptools/inactiveRegions');
 const CompileCommandsPathsNotification:  NotificationType<CompileCommandsPaths, void> = new NotificationType<CompileCommandsPaths, void>('cpptools/compileCommandsPaths');
 const UpdateClangFormatPathNotification: NotificationType<string, void> = new NotificationType<string, void>('cpptools/updateClangFormatPath');
+const UpdateIntelliSenseCachePathNotification: NotificationType<string, void> = new NotificationType<string, void>('cpptools/updateIntelliSenseCachePath');
 
 class BlockingTask<T> {
     private dependency: BlockingTask<any>;
@@ -200,7 +236,10 @@ export interface Client {
     updateCustomConfigurations(requestingProvider?: CustomConfigurationProvider1): Thenable<void>;
     updateCustomBrowseConfiguration(requestingProvider?: CustomConfigurationProvider1): Thenable<void>;
     provideCustomConfiguration(document: vscode.TextDocument): Promise<void>;
+    logDiagnostics(): Promise<void>;
     getCurrentConfigName(): Thenable<string>;
+    getCompilerPath(): Thenable<string>;
+    getKnownCompilers(): Thenable<configs.KnownCompiler[]>;
     takeOwnership(document: vscode.TextDocument): void;
     queueTask<T>(task: () => Thenable<T>): Thenable<T>;
     requestWhenReady(request: () => Thenable<any>): Thenable<any>;
@@ -219,9 +258,12 @@ export interface Client {
     handleConfigurationProviderSelectCommand(): void;
     handleShowParsingCommands(): void;
     handleConfigurationEditCommand(): void;
+    handleConfigurationEditJSONCommand(): void;
+    handleConfigurationEditUICommand(): void;
     handleAddToIncludePathCommand(path: string): void;
     onInterval(): void;
     dispose(): Thenable<void>;
+    addFileAssociations(fileAssociations: string, is_c: boolean): void;
 }
 
 export function createClient(allClients: ClientCollection, workspaceFolder?: vscode.WorkspaceFolder): Client {
@@ -241,6 +283,7 @@ class DefaultClient implements Client {
     private trackedDocuments = new Set<vscode.TextDocument>();
     private outputChannel: vscode.OutputChannel;
     private debugChannel: vscode.OutputChannel;
+    private diagnosticsChannel: vscode.OutputChannel;
     private crashTimes: number[] = [];
     private isSupported: boolean = true;
     private inactiveRegionsDecorations = new Map<string, DecorationRangesPair>();
@@ -314,12 +357,6 @@ class DefaultClient implements Client {
                     this.configuration.CompileCommandsChanged((e) => this.onCompileCommandsChanged(e));
                     this.disposables.push(this.configuration);
 
-                    // The configurations will not be sent to the language server until the default include paths and frameworks have been set.
-                    // The event handlers must be set before this happens.
-                    languageClient.sendRequest(QueryCompilerDefaultsRequest, {}).then((compilerDefaults: configs.CompilerDefaults) => {
-                        this.configuration.CompilerDefaults = compilerDefaults;
-                    });
-
                     this.languageClient = languageClient;
                     this.settingsTracker = getTracker(this.RootUri);
                     telemetry.logLanguageServerEvent("NonDefaultInitialCppSettings", this.settingsTracker.getUserModifiedSettings());
@@ -328,6 +365,16 @@ class DefaultClient implements Client {
                     // Listen for messages from the language server.
                     this.registerNotifications();
                     this.registerFileWatcher();
+
+                    // The configurations will not be sent to the language server until the default include paths and frameworks have been set.
+                    // The event handlers must be set before this happens.
+                    return languageClient.sendRequest(QueryCompilerDefaultsRequest, {}).then((compilerDefaults: configs.CompilerDefaults) => {
+                        this.configuration.CompilerDefaults = compilerDefaults;
+                            
+                        // Only register the real commands after the extension has finished initializing,
+                        // e.g. prevents empty c_cpp_properties.json from generation.
+                        registerCommands();
+                    });
                 },
                 (err) => {
                     this.isSupported = false;   // Running on an OS we don't support yet.
@@ -353,6 +400,11 @@ class DefaultClient implements Client {
 
     private createLanguageClient(allClients: ClientCollection, workspaceFolder?: vscode.WorkspaceFolder): LanguageClient {
         let serverModule: string = getLanguageServerFileName();
+        let exeExists: boolean = fs.existsSync(serverModule);
+        if (!exeExists) {
+            telemetry.logLanguageServerEvent("missingLanguageServerBinary");
+            throw String('Missing binary at ' + serverModule);
+        }
         let serverName: string = this.getName(workspaceFolder);
 
         let serverOptions: ServerOptions = {
@@ -362,12 +414,23 @@ class DefaultClient implements Client {
         let settings: CppSettings = new CppSettings(workspaceFolder ? workspaceFolder.uri : null);
         let other: OtherSettings = new OtherSettings(workspaceFolder ? workspaceFolder.uri : null);
 
-        let storagePath: string = util.extensionContext.storagePath;
+        let storagePath: string = util.extensionContext ? util.extensionContext.storagePath :
+            path.join((workspaceFolder ? workspaceFolder.uri.fsPath : ""), "/.vscode");
         if (vscode.workspace.workspaceFolders && vscode.workspace.workspaceFolders.length > 1) {
             storagePath = path.join(storagePath, serverName);
         }
 
         let abTestSettings: ABTestSettings = getABTestSettings();
+        
+        let intelliSenseCacheDisabled: boolean = false;
+        if (os.platform() === "darwin") {
+            const releaseParts: string[] = os.release().split(".");
+            if (releaseParts.length >= 1) {
+                // AutoPCH doesn't work for older Mac OS's.
+                intelliSenseCacheDisabled = parseInt(releaseParts[0]) < 17;
+            }
+        }
+
         let clientOptions: LanguageClientOptions = {
             documentSelector: [
                 { scheme: 'file', language: 'cpp' },
@@ -384,16 +447,20 @@ class DefaultClient implements Client {
                 clang_format_fallbackStyle: settings.clangFormatFallbackStyle,
                 clang_format_sortIncludes: settings.clangFormatSortIncludes,
                 formatting: settings.formatting,
-                extension_path: util.extensionContext.extensionPath,
+                extension_path: util.extensionPath,
                 exclude_files: other.filesExclude,
                 exclude_search: other.searchExclude,
                 storage_path: storagePath,
                 tab_size: other.editorTabSize,
                 intelliSenseEngine: settings.intelliSenseEngine,
                 intelliSenseEngineFallback: settings.intelliSenseEngineFallback,
+                intelliSenseCacheDisabled: intelliSenseCacheDisabled,
+                intelliSenseCachePath : util.resolveVariables(settings.intelliSenseCachePath, this.AdditionalEnvironment),
+                intelliSenseCacheSize : settings.intelliSenseCacheSize,
                 autocomplete: settings.autoComplete,
                 errorSquiggles: settings.errorSquiggles,
                 dimInactiveRegions: settings.dimInactiveRegions,
+                suggestSnippets: settings.suggestSnippets,
                 loggingLevel: settings.loggingLevel,
                 workspaceParsingPriority: settings.workspaceParsingPriority,
                 workspaceSymbols: settings.workspaceSymbols,
@@ -450,6 +517,10 @@ class DefaultClient implements Client {
                 let settings: CppSettings = new CppSettings(this.RootUri);
                 this.languageClient.sendNotification(UpdateClangFormatPathNotification, util.resolveVariables(settings.clangFormatPath, this.AdditionalEnvironment));
             }
+            if (changedSettings["intelliSenseCachePath"]) {
+                let settings: CppSettings = new CppSettings(this.RootUri);
+                this.languageClient.sendNotification(UpdateIntelliSenseCachePathNotification, util.resolveVariables(settings.intelliSenseCachePath, this.AdditionalEnvironment));
+            }
             this.configuration.onDidChangeSettings();
             telemetry.logLanguageServerEvent("CppSettingsChange", changedSettings, null);
         }
@@ -577,6 +648,18 @@ class DefaultClient implements Client {
         });
     }
 
+    public async logDiagnostics(): Promise<void> {
+        let response: GetDiagnosticsResult = await this.requestWhenReady(() => this.languageClient.sendRequest(GetDiagnosticsRequest, null));
+        if (!this.diagnosticsChannel) {
+            this.diagnosticsChannel = vscode.window.createOutputChannel("C/C++ Diagnostics");
+            this.disposables.push(this.diagnosticsChannel);
+        }
+        let header: string = `-------- Diagnostics - ${new Date().toLocaleString()}\n`;
+        let version: string = `Version: ${util.packageJson.version}\n`;
+        this.diagnosticsChannel.appendLine(`${header}${version}${response.diagnostics}`);
+        this.diagnosticsChannel.show(false);
+    }
+
     public async provideCustomConfiguration(document: vscode.TextDocument): Promise<void> {
         let tokenSource: CancellationTokenSource = new CancellationTokenSource();
         let providers: CustomConfigurationProviderCollection = getCustomConfigProviders();
@@ -590,6 +673,15 @@ class DefaultClient implements Client {
         }
 
         let providerName: string = providerId;
+        let params: QueryTranslationUnitSourceParams = {
+            uri: document.uri.toString()
+        };
+        let response: QueryTranslationUnitSourceResult = await this.requestWhenReady(() => this.languageClient.sendRequest(QueryTranslationUnitSourceRequest, params));
+        if (response.configDisposition === QueryTranslationUnitSourceConfigDisposition.ConfigNotNeeded) {
+            return Promise.resolve();
+        }
+
+        let tuUri: vscode.Uri = vscode.Uri.parse(response.uri);
         let configName: string = await this.getCurrentConfigName();
         const notReadyMessage: string = `${providerName} is not ready`;
         let provideConfigurationAsync: () => Thenable<SourceFileConfigurationItem[]> = async () => {
@@ -602,8 +694,8 @@ class DefaultClient implements Client {
                     }
 
                     providerName = provider.name;
-                    if (await provider.canProvideConfiguration(document.uri, tokenSource.token)) {
-                        return provider.provideConfigurations([document.uri], tokenSource.token);
+                    if (await provider.canProvideConfiguration(tuUri, tokenSource.token)) {
+                        return provider.provideConfigurations([tuUri], tokenSource.token);
                     }
                 }
             } catch (err) {
@@ -616,6 +708,11 @@ class DefaultClient implements Client {
             (configs: SourceFileConfigurationItem[]) => {
                 if (configs && configs.length > 0) {
                     this.sendCustomConfigurations(configs, true);
+                    if (response.configDisposition === QueryTranslationUnitSourceConfigDisposition.AncestorConfigNeeded) {
+                        // replacing uri with original uri
+                        let newConfig: SourceFileConfigurationItem =  { uri: document.uri, configuration: configs[0].configuration };
+                        this.sendCustomConfigurations([newConfig], true);
+                    }
                 }
             },
             (err) => {
@@ -623,7 +720,7 @@ class DefaultClient implements Client {
                     return;
                 }
                 let settings: CppSettings = new CppSettings(this.RootUri);
-                if (settings.configurationWarnings === "Enabled" && !this.isExternalHeader(document) && !vscode.debug.activeDebugSession) {
+                if (settings.configurationWarnings === "Enabled" && !this.isExternalHeader(document.uri) && !vscode.debug.activeDebugSession) {
                     const dismiss: string = "Dismiss";
                     const disable: string = "Disable Warnings";
                     let message: string = `'${providerName}' is unable to provide IntelliSense configuration information for '${document.uri.fsPath}'. ` +
@@ -644,8 +741,8 @@ class DefaultClient implements Client {
             });
     }
 
-    private isExternalHeader(document: vscode.TextDocument): boolean {
-        return util.isHeader(document) && !document.uri.toString().startsWith(this.RootUri.toString());
+    private isExternalHeader(uri: vscode.Uri): boolean {
+        return util.isHeader(uri) && !uri.toString().startsWith(this.RootUri.toString());
     }
 
     private getCustomConfigurationProviderId(): Thenable<string|undefined> {
@@ -656,6 +753,14 @@ class DefaultClient implements Client {
         return this.queueTask(() => Promise.resolve(this.configuration.CurrentConfiguration.name));
     }
 
+    public getCompilerPath(): Thenable<string> {
+        return this.queueTask(() => Promise.resolve(this.configuration.CompilerPath));
+    }
+
+    public getKnownCompilers(): Thenable<configs.KnownCompiler[]> {
+        return this.queueTask(() => Promise.resolve(this.configuration.KnownCompiler));
+    }
+
     /**
      * Take ownership of a document that was previously serviced by another client.
      * This process involves sending a textDocument/didOpen message to the server so
@@ -845,7 +950,11 @@ class DefaultClient implements Client {
 
         // TODO: Move this code to a different place?
         if (cppSettings.autoAddFileAssociations && payload.navigation.startsWith("<def")) {
-            this.addFileAssociations(payload.navigation.substr(4));
+            let fileAssociations: string = payload.navigation.substr(4);
+            let is_c: boolean = fileAssociations.startsWith("c");
+            // Skip over rest of header: c>; or >;
+            fileAssociations = fileAssociations.substr(is_c ? 3 : 2);
+            this.addFileAssociations(fileAssociations, is_c);
             return;
         }
 
@@ -859,41 +968,41 @@ class DefaultClient implements Client {
         this.model.navigationLocation.Value = currentNavigation;
     }
 
-    private addFileAssociations(fileAssociations: string): void {
+    public addFileAssociations(fileAssociations: string, is_c: boolean): void {
         let settings: OtherSettings = new OtherSettings(this.RootUri);
         let assocs: any = settings.filesAssociations;
-        let is_c: boolean = fileAssociations.startsWith("c");
 
-        // Skip over rest of header: c>; or >;
-        fileAssociations = fileAssociations.substr(is_c ? 3 : 2);
         let filesAndPaths: string[] = fileAssociations.split(";");
         let foundNewAssociation: boolean = false;
-        for (let i: number = 0; i < filesAndPaths.length - 1; ++i) {
+        for (let i: number = 0; i < filesAndPaths.length; ++i) {
             let fileAndPath: string[] = filesAndPaths[i].split("@");
-            let file: string = fileAndPath[0];
-            let filePath: string = fileAndPath[1];
-            if ((file in assocs) || (("**/" + file) in assocs)) {
-                continue; // File already has an association.
-            }
-            let j: number = file.lastIndexOf('.');
-            if (j !== -1) {
-                let ext: string = file.substr(j);
-                if ((("*" + ext) in assocs) || (("**/*" + ext) in assocs)) {
-                    continue; // Extension already has an association.
+            // Skip empty or malformed
+            if (fileAndPath.length === 2) {
+                let file: string = fileAndPath[0];
+                let filePath: string = fileAndPath[1];
+                if ((file in assocs) || (("**/" + file) in assocs)) {
+                    continue; // File already has an association.
                 }
-            }
-            let foundGlobMatch: boolean = false;
-            for (let assoc in assocs) {
-                if (minimatch(filePath, assoc)) {
-                    foundGlobMatch = true;
-                    break; // Assoc matched a glob pattern.
+                let j: number = file.lastIndexOf('.');
+                if (j !== -1) {
+                    let ext: string = file.substr(j);
+                    if ((("*" + ext) in assocs) || (("**/*" + ext) in assocs)) {
+                        continue; // Extension already has an association.
+                    }
                 }
+                let foundGlobMatch: boolean = false;
+                for (let assoc in assocs) {
+                    if (minimatch(filePath, assoc)) {
+                        foundGlobMatch = true;
+                        break; // Assoc matched a glob pattern.
+                    }
+                }
+                if (foundGlobMatch) {
+                    continue;
+                }
+                assocs[file] = is_c ? "c" : "cpp";
+                foundNewAssociation = true;
             }
-            if (foundGlobMatch) {
-                continue;
-            }
-            assocs[file] = is_c ? "c" : "cpp";
-            foundNewAssociation = true;
         }
         if (foundNewAssociation) {
             settings.filesAssociations = assocs;
@@ -923,22 +1032,31 @@ class DefaultClient implements Client {
             let showIntelliSenseFallbackMessage: PersistentState<boolean> = new PersistentState<boolean>("CPP.showIntelliSenseFallbackMessage", true);
             if (showIntelliSenseFallbackMessage.Value) {
                 ui.showConfigureIncludePathMessage(() => {
-                    let learnMorePanel: string = "Configuration Help";
+                    let configJSON: string = "Configure (JSON)";
+                    let configUI: string = "Configure (UI)";
                     let dontShowAgain: string = "Don't Show Again";
                     let fallbackMsg: string = this.configuration.VcpkgInstalled ?
                         "Update your IntelliSense settings or use Vcpkg to install libraries to help find missing headers." :
                         "Configure your IntelliSense settings to help find missing headers.";
-                    return vscode.window.showInformationMessage(fallbackMsg, learnMorePanel, dontShowAgain).then((value) => {
+                    return vscode.window.showInformationMessage(fallbackMsg, configJSON, configUI, dontShowAgain).then((value) => {
                         switch (value) {
-                            case learnMorePanel:
-                                let uri: vscode.Uri = vscode.Uri.parse(`https://go.microsoft.com/fwlink/?linkid=864631`);
-                                vscode.commands.executeCommand('vscode.open', uri);
+                            case configJSON:
+                                vscode.commands.getCommands(true).then((commands: string[]) => {
+                                    if (commands.indexOf("workbench.action.problems.focus") >= 0) {
+                                         vscode.commands.executeCommand("workbench.action.problems.focus");
+                                   }
+                                });
+                                this.handleConfigurationEditJSONCommand();
+                                telemetry.logLanguageServerEvent("SettingsCommand", { "toast": "json" }, null);
+                                break;
+                            case configUI:
                                 vscode.commands.getCommands(true).then((commands: string[]) => {
                                     if (commands.indexOf("workbench.action.problems.focus") >= 0) {
                                         vscode.commands.executeCommand("workbench.action.problems.focus");
-                                    }
+                                }
                                 });
-                                this.handleConfigurationEditCommand();
+                                this.handleConfigurationEditUICommand();
+                                telemetry.logLanguageServerEvent("SettingsCommand", { "toast": "ui" }, null);
                                 break;
                             case dontShowAgain:
                                 showIntelliSenseFallbackMessage.Value = false;
@@ -1004,7 +1122,7 @@ class DefaultClient implements Client {
             return;
         }
 
-        let ask: PersistentState<boolean> = new PersistentState<boolean>("CPP.showCompileCommandsSelection", true);
+        let ask: PersistentFolderState<boolean> = new PersistentFolderState<boolean>("CPP.showCompileCommandsSelection", true, this.RootPath);
         if (!ask.Value) {
             return;
         }
@@ -1125,6 +1243,9 @@ class DefaultClient implements Client {
         }).then(() => {
             let newProvider: string = this.configuration.CurrentConfigurationProvider;
             if (this.configurationProvider !== newProvider) {
+                if (this.configurationProvider) {
+                    this.clearCustomConfigurations();
+                }
                 this.configurationProvider = newProvider;
                 this.updateCustomConfigurations();
                 this.updateCustomBrowseConfiguration();
@@ -1278,7 +1399,15 @@ class DefaultClient implements Client {
     }
 
     public handleConfigurationEditCommand(): void {
-        this.notifyWhenReady(() => this.configuration.handleConfigurationEditCommand(vscode.window.showTextDocument));
+        this.notifyWhenReady(() => this.configuration.handleConfigurationEditCommand(null, vscode.window.showTextDocument));
+    }
+
+    public handleConfigurationEditJSONCommand(): void {
+        this.notifyWhenReady(() => this.configuration.handleConfigurationEditJSONCommand(null, vscode.window.showTextDocument));
+    }
+
+    public handleConfigurationEditUICommand(): void {
+        this.notifyWhenReady(() => this.configuration.handleConfigurationEditUICommand(null, vscode.window.showTextDocument));
     }
 
     public handleAddToIncludePathCommand(path: string): void {
@@ -1343,7 +1472,10 @@ class NullClient implements Client {
     updateCustomConfigurations(requestingProvider?: CustomConfigurationProvider1): Thenable<void> { return Promise.resolve(); }
     updateCustomBrowseConfiguration(requestingProvider?: CustomConfigurationProvider1): Thenable<void> { return Promise.resolve(); }
     provideCustomConfiguration(document: vscode.TextDocument): Promise<void> { return Promise.resolve(); }
+    logDiagnostics(): Promise<void> { return Promise.resolve(); }
     getCurrentConfigName(): Thenable<string> { return Promise.resolve(""); }
+    getCompilerPath(): Thenable<string> { return Promise.resolve(""); }
+    getKnownCompilers(): Thenable<configs.KnownCompiler[]> { return Promise.resolve([]); }
     takeOwnership(document: vscode.TextDocument): void {}
     queueTask<T>(task: () => Thenable<T>): Thenable<T> { return task(); }
     requestWhenReady(request: () => Thenable<any>): Thenable<any> { return; }
@@ -1362,6 +1494,8 @@ class NullClient implements Client {
     handleConfigurationProviderSelectCommand(): void {}
     handleShowParsingCommands(): void {}
     handleConfigurationEditCommand(): void {}
+    handleConfigurationEditJSONCommand(): void {}
+    handleConfigurationEditUICommand(): void {}
     handleAddToIncludePathCommand(path: string): void {}
     onInterval(): void {}
     dispose(): Thenable<void> {
@@ -1369,4 +1503,5 @@ class NullClient implements Client {
         this.stringEvent.dispose();
         return Promise.resolve();
     }
+    addFileAssociations(fileAssociations: string, is_c: boolean): void {}
 }

Extension/src/LanguageServer/clientCollection.ts

@@ -119,7 +119,7 @@ export class ClientCollection {
                 this.languageClients.set(key, cpptools.createNullClient());
             }
 
-            if (this.activeClient === client) {
+            if (this.activeClient === client && this.activeDocument) {
                 this.activeClient = this.getClientFor(this.activeDocument.uri);
                 this.activeClient.activeDocumentChanged(this.activeDocument);
             }
@@ -154,7 +154,7 @@ export class ClientCollection {
                     client.TrackedDocuments.forEach(document => this.transferOwnership(document, client));
                     client.TrackedDocuments.clear();
 
-                    if (this.activeClient === client) {
+                    if (this.activeClient === client && this.activeDocument) {
                         // Need to make a different client the active client.
                         this.activeClient = this.getClientFor(this.activeDocument.uri);
                         this.activeClient.activeDocumentChanged(this.activeDocument);
@@ -175,7 +175,8 @@ export class ClientCollection {
     }
 
     private onDidOpenTextDocument(document: vscode.TextDocument): void {
-        if (document.languageId === "c" || document.languageId === "cpp") {
+        if (document.languageId === "c" || document.languageId === "cpp"
+            || document.languageId === "json" && document.uri.fsPath.endsWith("c_cpp_properties.json")) {
             // Make sure a client exists for this document's workspace.
             this.getClientFor(document.uri);
         }

Extension/src/LanguageServer/configurations.ts

@@ -10,9 +10,12 @@ import * as vscode from 'vscode';
 import * as util from '../common';
 import * as telemetry from '../telemetry';
 import { PersistentFolderState } from './persistentState';
-import { CppSettings } from './settings';
+import { CppSettings, OtherSettings } from './settings';
 import { ABTestSettings, getABTestSettings } from '../abTesting';
 import { getCustomConfigProviders } from './customProviders';
+import { SettingsPanel } from './settingsPanel';
+import * as os from 'os';
+import escapeStringRegExp = require('escape-string-regexp');
 const configVersion: number = 4;
 
 type Environment = { [key: string]: string | string[] };
@@ -41,11 +44,13 @@ export interface ConfigurationJson {
     configurations: Configuration[];
     env?: {[key: string]: string | string[]};
     version: number;
+    enableConfigurationSquiggles?: boolean;
 }
 
 export interface Configuration {
     name: string;
     compilerPath?: string;
+    knownCompilers?: KnownCompiler[];
     cStandard?: string;
     cppStandard?: string;
     includePath?: string[];
@@ -59,25 +64,38 @@ export interface Configuration {
     browse?: Browse;
 }
 
+export interface ConfigurationErrors {
+    compilerPath?: string;
+    includePath?: string;
+    intelliSenseMode?: string;
+}
+
 export interface Browse {
     path?: string[];
     limitSymbolsToIncludedHeaders?: boolean | string;
     databaseFilename?: string;
 }
 
+export interface KnownCompiler {
+    path: string;
+    isC: boolean;
+}
+
 export interface CompilerDefaults {
     compilerPath: string;
+    knownCompilers: KnownCompiler[];
     cStandard: string;
     cppStandard: string;
     includes: string[];
     frameworks: string[];
     windowsSdkVersion: string;
     intelliSenseMode: string;
+    rootfs: string;
 }
 
 export class CppProperties {
     private rootUri: vscode.Uri;
-    private propertiesFile: vscode.Uri = null;
+    private propertiesFile: vscode.Uri = undefined;
     private readonly configFolder: string;
     private configurationJson: ConfigurationJson = null;
     private currentConfigurationIndex: PersistentFolderState<number>;
@@ -85,6 +103,7 @@ export class CppProperties {
     private configFileWatcherFallbackTime: Date = new Date(); // Used when file watching fails.
     private compileCommandFileWatchers: fs.FSWatcher[] = [];
     private defaultCompilerPath: string = null;
+    private knownCompilers: KnownCompiler[] = null;
     private defaultCStandard: string = null;
     private defaultCppStandard: string = null;
     private defaultIncludes: string[] = null;
@@ -98,6 +117,10 @@ export class CppProperties {
     private configurationsChanged = new vscode.EventEmitter<Configuration[]>();
     private selectionChanged = new vscode.EventEmitter<number>();
     private compileCommandsChanged = new vscode.EventEmitter<string>();
+    private diagnosticCollection: vscode.DiagnosticCollection;
+    private prevSquiggleMetrics: Map<string, { [key: string]: number }> = new Map<string, { [key: string]: number }>();
+    private rootfs: string = null;
+    private settingsPanel: SettingsPanel = undefined;
 
     // Any time the default settings are parsed and assigned to `this.configurationJson`,
     // we want to track when the default includes have been added to it.
@@ -109,44 +132,19 @@ export class CppProperties {
         let rootPath: string = rootUri ? rootUri.fsPath : "";
         this.currentConfigurationIndex = new PersistentFolderState<number>("CppProperties.currentConfigurationIndex", -1, rootPath);
         this.configFolder = path.join(rootPath, ".vscode");
-
-        let configFilePath: string = path.join(this.configFolder, "c_cpp_properties.json");
-        if (fs.existsSync(configFilePath)) {
-            this.propertiesFile = vscode.Uri.file(configFilePath);
-            this.parsePropertiesFile();
-        }
-        if (!this.configurationJson) {
-            this.resetToDefaultSettings(this.CurrentConfigurationIndex === -1);
-        }
-
-        this.configFileWatcher = vscode.workspace.createFileSystemWatcher(path.join(this.configFolder, this.configurationGlobPattern));
-        this.disposables.push(this.configFileWatcher);
-        this.configFileWatcher.onDidCreate((uri) => {
-            this.propertiesFile = uri;
-            this.handleConfigurationChange();
-        });
-
-        this.configFileWatcher.onDidDelete(() => {
-            this.propertiesFile = null;
-            this.resetToDefaultSettings(true);
-            this.handleConfigurationChange();
-        });
-
-        this.configFileWatcher.onDidChange(() => {
-            this.handleConfigurationChange();
-        });
-
+        this.diagnosticCollection = vscode.languages.createDiagnosticCollection(rootPath);
         this.buildVcpkgIncludePath();
-
         this.disposables.push(vscode.Disposable.from(this.configurationsChanged, this.selectionChanged, this.compileCommandsChanged));
     }
 
     public get ConfigurationsChanged(): vscode.Event<Configuration[]> { return this.configurationsChanged.event; }
     public get SelectionChanged(): vscode.Event<number> { return this.selectionChanged.event; }
     public get CompileCommandsChanged(): vscode.Event<string> { return this.compileCommandsChanged.event; }
-    public get Configurations(): Configuration[] { return this.configurationJson.configurations; }
+    public get Configurations(): Configuration[] { return this.configurationJson ? this.configurationJson.configurations : null; }
     public get CurrentConfigurationIndex(): number { return this.currentConfigurationIndex.Value; }
-    public get CurrentConfiguration(): Configuration { return this.Configurations[this.CurrentConfigurationIndex]; }
+    public get CurrentConfiguration(): Configuration { return this.Configurations ? this.Configurations[this.CurrentConfigurationIndex] : null; }
+    public get CompilerPath(): string { return this.CurrentConfiguration ? this.CurrentConfiguration.compilerPath : null; }
+    public get KnownCompiler(): KnownCompiler[] { return this.knownCompilers; }
 
     public get CurrentConfigurationProvider(): string|null {
         if (this.CurrentConfiguration.configurationProvider) {
@@ -163,15 +161,59 @@ export class CppProperties {
 
     public set CompilerDefaults(compilerDefaults: CompilerDefaults) {
         this.defaultCompilerPath = compilerDefaults.compilerPath;
+        this.knownCompilers = compilerDefaults.knownCompilers;
         this.defaultCStandard = compilerDefaults.cStandard;
         this.defaultCppStandard = compilerDefaults.cppStandard;
         this.defaultIncludes = compilerDefaults.includes;
         this.defaultFrameworks = compilerDefaults.frameworks;
         this.defaultWindowsSdkVersion = compilerDefaults.windowsSdkVersion;
         this.defaultIntelliSenseMode = compilerDefaults.intelliSenseMode;
+        this.rootfs = compilerDefaults.rootfs;
 
         // defaultPaths is only used when there isn't a c_cpp_properties.json, but we don't send the configuration changed event
         // to the language server until the default include paths and frameworks have been sent.
+        let configFilePath: string = path.join(this.configFolder, "c_cpp_properties.json");
+        if (fs.existsSync(configFilePath)) {
+            this.propertiesFile = vscode.Uri.file(configFilePath);
+        } else {
+            this.propertiesFile = null;
+        }
+        
+        let settingsPath: string = path.join(this.configFolder, this.configurationGlobPattern);
+        this.configFileWatcher = vscode.workspace.createFileSystemWatcher(settingsPath);
+        this.disposables.push(this.configFileWatcher);
+        this.configFileWatcher.onDidCreate((uri) => {
+            this.propertiesFile = uri;
+            this.handleConfigurationChange();
+        });
+
+        this.configFileWatcher.onDidDelete(() => {
+            this.propertiesFile = null;
+            this.resetToDefaultSettings(true);
+            this.handleConfigurationChange();
+        });
+
+        this.configFileWatcher.onDidChange(() => {
+            // If the file is one of the textDocument's vscode is tracking, we need to wait for an
+            // onDidChangeTextDocument event, or we may get old/cached contents when we open it.
+            let alreadyTracking: boolean = false;
+            for (let i: number = 0; i < vscode.workspace.textDocuments.length; i++) {
+                if (vscode.workspace.textDocuments[i].uri.fsPath === settingsPath) {
+                    alreadyTracking = true;
+                    break;
+                }
+            }
+            if (!alreadyTracking) {
+                this.handleConfigurationChange();
+            }
+        });
+
+        vscode.workspace.onDidChangeTextDocument((e: vscode.TextDocumentChangeEvent) => {
+            if (e.document.uri.fsPath === settingsPath) {
+                this.handleConfigurationChange();
+            }
+        });
+
         this.handleConfigurationChange();
     }
 
@@ -185,6 +227,23 @@ export class CppProperties {
 
     private onSelectionChanged(): void {
         this.selectionChanged.fire(this.CurrentConfigurationIndex);
+        if (this.settingsPanel) {
+            this.ensurePropertiesFile().then(() => {
+                if (this.propertiesFile) {
+                    // Clear out any modifications we may have made internally by parsing the json file
+                    if (this.parsePropertiesFile(false)) {
+                        // Update the UI with new selected configuration
+                        this.settingsPanel.updateConfigUI(
+                            this.configurationJson.configurations[this.currentConfigurationIndex.Value],
+                            this.getErrorsForConfigUI());
+                    } else {
+                        // Parse failed, open json file
+                        vscode.workspace.openTextDocument(this.propertiesFile);
+                    }
+                }
+            });
+        }
+        this.handleSquiggles();
     }
 
     private onCompileCommandsChanged(path: string): void {
@@ -242,9 +301,15 @@ export class CppProperties {
             if (isUnset(settings.defaultWindowsSdkVersion) && this.defaultWindowsSdkVersion && process.platform === 'win32') {
                 configuration.windowsSdkVersion = this.defaultWindowsSdkVersion;
             }
-            if (isUnset(settings.defaultCompilerPath) && this.defaultCompilerPath) {
+            if (isUnset(settings.defaultCompilerPath) && this.defaultCompilerPath &&
+                isUnset(settings.defaultCompileCommands) && !configuration.compileCommands) {
+                // compile_commands.json already specifies a compiler. compilerPath overrides the compile_commands.json compiler so
+                // don't set a default when compileCommands is in use.
                 configuration.compilerPath = this.defaultCompilerPath;
             }
+            if (this.knownCompilers) {
+                configuration.knownCompilers = this.knownCompilers;
+            }
             if (isUnset(settings.defaultCStandard) && this.defaultCStandard) {
                 configuration.cStandard = this.defaultCStandard;
             }
@@ -332,35 +397,51 @@ export class CppProperties {
         }
     }
 
+    private isCompilerIntelliSenseModeCompatible(): boolean {
+        // Check if intelliSenseMode and compilerPath are compatible
+        // cl.exe and msvc mode should be used together
+        // Ignore if compiler path is not set or intelliSenseMode is not set
+        if (this.CurrentConfiguration.compilerPath === undefined ||
+            this.CurrentConfiguration.compilerPath === "" ||
+            this.CurrentConfiguration.compilerPath === "${default}" ||
+            this.CurrentConfiguration.intelliSenseMode === undefined || 
+            this.CurrentConfiguration.intelliSenseMode === "" || 
+            this.CurrentConfiguration.intelliSenseMode === "${default}")  {
+            return true;
+        }
+        let compilerPathAndArgs: util.CompilerPathAndArgs = util.extractCompilerPathAndArgs(this.CurrentConfiguration.compilerPath);
+        return compilerPathAndArgs.compilerPath.endsWith("cl.exe") === (this.CurrentConfiguration.intelliSenseMode === "msvc-x64");
+    }
+
     public addToIncludePathCommand(path: string): void {
-        this.handleConfigurationEditCommand((document: vscode.TextDocument) => {
+        this.handleConfigurationEditCommand(() => {
             telemetry.logLanguageServerEvent("addToIncludePath");
-            this.parsePropertiesFile(); // Clear out any modifications we may have made internally.
+            this.parsePropertiesFile(true); // Clear out any modifications we may have made internally.
             let config: Configuration = this.CurrentConfiguration;
             if (config.includePath === undefined) {
                 config.includePath = ["${default}"];
             }
             config.includePath.splice(config.includePath.length, 0, path);
-            fs.writeFileSync(this.propertiesFile.fsPath, JSON.stringify(this.configurationJson, null, 4));
+            this.writeToJson();
             this.handleConfigurationChange();
-        });
+        }, null);
     }
 
     public updateCustomConfigurationProvider(providerId: string): Thenable<void> {
         return new Promise<void>((resolve) => {
             if (this.propertiesFile) {
-                this.handleConfigurationEditCommand((document: vscode.TextDocument) => {
-                    this.parsePropertiesFile(); // Clear out any modifications we may have made internally.
+                this.handleConfigurationEditJSONCommand(() => {
+                    this.parsePropertiesFile(true); // Clear out any modifications we may have made internally.
                     let config: Configuration = this.CurrentConfiguration;
                     if (providerId) {
                         config.configurationProvider = providerId;
                     } else {
                         delete config.configurationProvider;
                     }
-                    fs.writeFileSync(this.propertiesFile.fsPath, JSON.stringify(this.configurationJson, null, 4));
+                    this.writeToJson();
                     this.handleConfigurationChange();
                     resolve();
-                });
+                }, null);
             } else {
                 let settings: CppSettings = new CppSettings(this.rootUri);
                 if (providerId) {
@@ -375,20 +456,25 @@ export class CppProperties {
     }
 
     public setCompileCommands(path: string): void {
-        this.handleConfigurationEditCommand((document: vscode.TextDocument) => {
-            this.parsePropertiesFile(); // Clear out any modifications we may have made internally.
+        this.handleConfigurationEditJSONCommand(() => {
+            this.parsePropertiesFile(true); // Clear out any modifications we may have made internally.
             let config: Configuration = this.CurrentConfiguration;
             config.compileCommands = path;
-            fs.writeFileSync(this.propertiesFile.fsPath, JSON.stringify(this.configurationJson, null, 4));
+            this.writeToJson();
             this.handleConfigurationChange();
-        });
+        }, null);
     }
 
     public select(index: number): Configuration {
         if (index === this.configurationJson.configurations.length) {
-            this.handleConfigurationEditCommand(vscode.window.showTextDocument);
+            this.handleConfigurationEditUICommand(null, vscode.window.showTextDocument);
             return;
         }
+        if (index === this.configurationJson.configurations.length + 1) {
+            this.handleConfigurationEditJSONCommand(null, vscode.window.showTextDocument);
+            return;
+        }
+
         this.currentConfigurationIndex.Value = index;
         this.onSelectionChanged();
     }
@@ -412,9 +498,9 @@ export class CppProperties {
     private resolveAndSplit(paths: string[] | undefined, defaultValue: string[], env: Environment): string[] {
         let result: string[] = [];
         if (paths) {
+            paths = this.resolveDefaults(paths, defaultValue);
             paths.forEach(entry => {
                 let entries: string[] = util.resolveVariables(entry, env).split(";").filter(e => e);
-                entries = this.resolveDefaults(entries, defaultValue);
                 result = result.concat(entries);
             });
         }
@@ -450,6 +536,9 @@ export class CppProperties {
     }
 
     private updateServerOnFolderSettingsChange(): void {
+        if (!this.configurationJson) {
+            return;
+        }
         let settings: CppSettings = new CppSettings(this.rootUri);
         let env: Environment = this.ExtendedEnvironment;
         for (let i: number = 0; i < this.configurationJson.configurations.length; i++) {
@@ -478,7 +567,7 @@ export class CppProperties {
                     // If the user doesn't set browse.path, copy the includePath over. Make sure ${workspaceFolder} is in there though...
                     configuration.browse.path = configuration.includePath.slice(0);
                     if (-1 === configuration.includePath.findIndex((value: string, index: number) => {
-                        return !!value.match(/^\$\{(workspaceRoot|workspaceFolder)\}(\\|\\\*\*|\/|\/\*\*)?$/g);
+                        return !!value.match(/^\$\{(workspaceRoot|workspaceFolder)\}(\\\*{0,2}|\/\*{0,2})?$/g);
                     })) {
                         configuration.browse.path.push("${workspaceFolder}");
                     }
@@ -522,56 +611,96 @@ export class CppProperties {
         }
     }
 
-    public handleConfigurationEditCommand(onSuccess: (document: vscode.TextDocument) => void): void {
-        if (this.propertiesFile && fs.existsSync(this.propertiesFile.fsPath)) {
-            vscode.workspace.openTextDocument(this.propertiesFile).then((document: vscode.TextDocument) => {
-                onSuccess(document);
-            });
+    public handleConfigurationEditCommand(onCreation: () => void, showDocument: (document: vscode.TextDocument) => void): void {
+        let otherSettings: OtherSettings = new OtherSettings(this.rootUri);
+        if (otherSettings.settingsEditor === "ui") {
+            this.handleConfigurationEditUICommand(onCreation, showDocument);
         } else {
-            fs.mkdir(this.configFolder, (e: NodeJS.ErrnoException) => {
-                if (!e || e.code === 'EEXIST') {
-                    let fullPathToFile: string = path.join(this.configFolder, "c_cpp_properties.json");
-                    let filePath: vscode.Uri = vscode.Uri.file(fullPathToFile).with({ scheme: "untitled" });
-                    vscode.workspace.openTextDocument(filePath).then((document: vscode.TextDocument) => {
-                        let edit: vscode.WorkspaceEdit = new vscode.WorkspaceEdit();
-                        if (this.configurationJson) {
-                            this.resetToDefaultSettings(true);
+            this.handleConfigurationEditJSONCommand(onCreation, showDocument);
+        }
+    }
+
+    public handleConfigurationEditJSONCommand(onCreation: () => void, showDocument: (document: vscode.TextDocument) => void): void {
+        this.ensurePropertiesFile().then(() => {
+            console.assert(this.propertiesFile);
+            if (onCreation) {
+                onCreation();
+            }
+            // Directly open the json file
+            vscode.workspace.openTextDocument(this.propertiesFile).then((document: vscode.TextDocument) => {
+                if (showDocument) {
+                    showDocument(document);
+                }
+            });
+        });
+    }
+
+    public handleConfigurationEditUICommand(onCreation: () => void, showDocument: (document: vscode.TextDocument) => void): void {
+        this.ensurePropertiesFile().then(() => {
+            if (this.propertiesFile) {
+                if (onCreation) {
+                    onCreation();
+                }
+                if (this.parsePropertiesFile(false)) {
+                    // Parse successful, show UI
+                    if (this.settingsPanel === undefined) {
+                        this.settingsPanel = new SettingsPanel();
+                        this.settingsPanel.SettingsPanelActivated(() => this.onSettingsPanelActivated());
+                        this.settingsPanel.ConfigValuesChanged(() => this.saveConfigurationUI());
+                        this.disposables.push(this.settingsPanel);
+                    }
+                    this.settingsPanel.createOrShow(
+                        this.configurationJson.configurations[this.currentConfigurationIndex.Value],
+                        this.getErrorsForConfigUI());
+                } else {
+                    // Parse failed, open json file
+                    vscode.workspace.openTextDocument(this.propertiesFile).then((document: vscode.TextDocument) => {
+                        if (showDocument) {
+                            showDocument(document);
                         }
-                        this.applyDefaultIncludePathsAndFrameworks();
-                        let settings: CppSettings = new CppSettings(this.rootUri);
-                        if (settings.defaultConfigurationProvider) {
-                            this.configurationJson.configurations.forEach(config => {
-                                config.configurationProvider = settings.defaultConfigurationProvider;
-                            });
-                            settings.update("default.configurationProvider", undefined); // delete the setting
-                        }
-                        edit.insert(document.uri, new vscode.Position(0, 0), JSON.stringify(this.configurationJson, null, 4));
-                        vscode.workspace.applyEdit(edit).then((status) => {
-                            // Fix for issue 163
-                            // https://github.com/Microsoft/vscppsamples/issues/163
-                            // Save the file to disk so that when the user tries to re-open the file it exists.
-                            // Before this fix the file existed but was unsaved, so we went through the same
-                            // code path and reapplied the edit.
-                            document.save().then(() => {
-                                this.propertiesFile = vscode.Uri.file(path.join(this.configFolder, "c_cpp_properties.json"));
-                                vscode.workspace.openTextDocument(this.propertiesFile).then((document: vscode.TextDocument) => {
-                                    onSuccess(document);
-                                });
-                            });
-                        });
                     });
                 }
+            }
+        });
+    }
+
+    private onSettingsPanelActivated(): void {
+        if (this.configurationJson) {
+            this.ensurePropertiesFile().then(() => {
+                if (this.propertiesFile) {
+                    if (this.parsePropertiesFile(false)) {
+                        // The settings UI became visible or active.
+                        // Ensure settingsPanel has copy of latest current configuration
+                        this.settingsPanel.updateConfigUI(
+                            this.configurationJson.configurations[this.currentConfigurationIndex.Value],
+                            this.getErrorsForConfigUI());
+                    } else {
+                        // Parse failed, open json file
+                        vscode.workspace.openTextDocument(this.propertiesFile);
+                    }
+                }
             });
         }
     }
 
+    private saveConfigurationUI(): void {
+        this.parsePropertiesFile(false); // Clear out any modifications we may have made internally.
+        let config: Configuration = this.settingsPanel.getLastValuesFromConfigUI();
+        this.configurationJson.configurations[this.currentConfigurationIndex.Value] = config;
+        this.settingsPanel.updateErrors(this.getErrorsForConfigUI());
+        this.writeToJson();
+    }
+
     private handleConfigurationChange(): void {
+        if (this.propertiesFile === undefined) {
+            return; // Occurs when propertiesFile hasn't been checked yet.
+        }
         this.configFileWatcherFallbackTime = new Date();
         if (this.propertiesFile) {
-            this.parsePropertiesFile();
+            this.parsePropertiesFile(true);
             // parsePropertiesFile can fail, but it won't overwrite an existing configurationJson in the event of failure.
             // this.configurationJson should only be undefined here if we have never successfully parsed the propertiesFile.
-            if (this.configurationJson !== undefined) {
+            if (this.configurationJson) {
                 if (this.CurrentConfigurationIndex < 0 ||
                     this.CurrentConfigurationIndex >= this.configurationJson.configurations.length) {
                     // If the index is out of bounds (during initialization or due to removal of configs), fix it.
@@ -580,7 +709,7 @@ export class CppProperties {
             }
         }
 
-        if (this.configurationJson === undefined) {
+        if (!this.configurationJson) {
             this.resetToDefaultSettings(true);  // I don't think there's a case where this will be hit anymore.
         }
 
@@ -588,13 +717,55 @@ export class CppProperties {
         this.updateServerOnFolderSettingsChange();
     }
 
-    private parsePropertiesFile(): void {
+    private async ensurePropertiesFile(): Promise<void> {
+        if (this.propertiesFile && fs.existsSync(this.propertiesFile.fsPath)) {
+            return;
+        } else {
+            try {
+                if  (!fs.existsSync(this.configFolder)) {
+                    fs.mkdirSync(this.configFolder);
+                }
+
+                let fullPathToFile: string = path.join(this.configFolder, "c_cpp_properties.json");
+                if (this.configurationJson) {
+                    this.resetToDefaultSettings(true);
+                }
+                this.applyDefaultIncludePathsAndFrameworks();
+                let settings: CppSettings = new CppSettings(this.rootUri);
+                if (settings.defaultConfigurationProvider) {
+                    this.configurationJson.configurations.forEach(config => {
+                        config.configurationProvider = settings.defaultConfigurationProvider;
+                    });
+                    settings.update("default.configurationProvider", undefined); // delete the setting
+                }
+                let savedKnownCompilers: KnownCompiler[] = this.configurationJson.configurations[0].knownCompilers;
+                delete this.configurationJson.configurations[0].knownCompilers;
+
+                await util.writeFileText(fullPathToFile, JSON.stringify(this.configurationJson, null, 4));
+                this.configurationJson.configurations[0].knownCompilers = savedKnownCompilers;
+
+                this.propertiesFile = vscode.Uri.file(path.join(this.configFolder, "c_cpp_properties.json"));
+
+            } catch (err) {
+                vscode.window.showErrorMessage(`Failed to create "${this.configFolder}": ${err.message}`);
+            }
+        }
+        return;
+    }
+
+    private parsePropertiesFile(handleSquiggles: boolean): boolean {
+        let success: boolean = true;
         try {
             let readResults: string = fs.readFileSync(this.propertiesFile.fsPath, 'utf8');
             if (readResults === "") {
                 return; // Repros randomly when the file is initially created. The parse will get called again after the file is written.
             }
 
+            if (handleSquiggles) {
+                // Replace all \<escape character> with \\<character>, except for \"
+                // Otherwise, the JSON.parse result will have the \<escape character> missing.
+                readResults = util.escapeForSquiggles(readResults);
+            }
             // Try to use the same configuration as before the change.
             let newJson: ConfigurationJson = JSON.parse(readResults);
             if (!newJson || !newJson.configurations || newJson.configurations.length === 0) {
@@ -655,16 +826,406 @@ export class CppProperties {
 
             if (dirty) {
                 try {
-                    fs.writeFileSync(this.propertiesFile.fsPath, JSON.stringify(this.configurationJson, null, 4));
+                    this.writeToJson();
                 } catch (err) {
                     // Ignore write errors, the file may be under source control. Updated settings will only be modified in memory.
-                    vscode.window.showWarningMessage('Attempt to update "' + this.propertiesFile.fsPath + '" failed (do you have write access?)');
+                    vscode.window.showWarningMessage(`Attempt to update "${this.propertiesFile.fsPath}" failed (do you have write access?)`);
+                    success = false;
                 }
             }
+
         } catch (err) {
-            vscode.window.showErrorMessage('Failed to parse "' + this.propertiesFile.fsPath + '": ' + err.message);
-            throw err;
+            vscode.window.showErrorMessage(`Failed to parse "${this.propertiesFile.fsPath}": ${err.message}`);
+            success = false;
         }
+
+        if (handleSquiggles && success) {
+            this.handleSquiggles();
+        }
+
+        return success;
+    }
+
+    private resolvePath(path: string, isWindows: boolean): string {
+        if (!path || path === "${default}") {
+            return "";
+        }
+
+        let result: string = "";
+
+        // first resolve variables
+        result = util.resolveVariables(path, this.ExtendedEnvironment);
+        if (result.includes("${workspaceFolder}")) {
+            result = result.replace("${workspaceFolder}", this.rootUri.fsPath);
+        }
+        if (result.includes("${workspaceRoot}")) {
+            result = result.replace("${workspaceRoot}", this.rootUri.fsPath);
+        }
+        if (result.includes("${vcpkgRoot}") && util.getVcpkgRoot()) {
+            result = result.replace("${vcpkgRoot}", util.getVcpkgRoot());
+        }
+        if (result.includes("*")) {
+            result = result.replace(/\*/g, "");
+        }
+
+        // resolve WSL paths
+        if (isWindows && result.startsWith("/")) {
+            const mntStr: string = "/mnt/";
+            if (result.length > "/mnt/c/".length && result.substr(0, mntStr.length) === mntStr) {
+                result = result.substr(mntStr.length);
+                result = result.substr(0, 1) + ":" + result.substr(1);
+            } else if (this.rootfs && this.rootfs.length > 0) {
+                result = this.rootfs + result.substr(1);
+                // TODO: Handle WSL symlinks.
+            }
+        }
+
+        return result;
+    }
+
+    private getErrorsForConfigUI(): ConfigurationErrors {
+        let errors: ConfigurationErrors = {};
+        const isWindows: boolean = os.platform() === 'win32';
+
+        // Validate compilerPath
+        let resolvedCompilerPath: string = this.resolvePath(this.CurrentConfiguration.compilerPath, isWindows);
+        let compilerPathAndArgs: util.CompilerPathAndArgs = util.extractCompilerPathAndArgs(resolvedCompilerPath);
+        if (resolvedCompilerPath &&
+            // Don't error cl.exe paths because it could be for an older preview build.
+            !(isWindows && compilerPathAndArgs.compilerPath.endsWith("cl.exe"))) {
+            resolvedCompilerPath = resolvedCompilerPath.trim();
+
+            // Error when the compiler's path has spaces without quotes but args are used.
+            // Except, exclude cl.exe paths because it could be for an older preview build.
+            let compilerPathNeedsQuotes: boolean =
+                compilerPathAndArgs.additionalArgs &&
+                !resolvedCompilerPath.startsWith('"') &&
+                compilerPathAndArgs.compilerPath.includes(" ");
+            
+            let compilerPathErrors: string[] = [];
+            if (compilerPathNeedsQuotes) {
+                compilerPathErrors.push(`Compiler path with spaces and arguments is missing double quotes " around the path.`);
+            }
+
+            // Get compiler path without arguments before checking if it exists
+            resolvedCompilerPath = compilerPathAndArgs.compilerPath;
+
+            let pathExists: boolean = true;
+            let existsWithExeAdded: (path: string) => boolean = (path: string) => {
+                return isWindows && !path.startsWith("/") && fs.existsSync(path + ".exe");
+            };
+            if (!fs.existsSync(resolvedCompilerPath)) {
+                if (existsWithExeAdded(resolvedCompilerPath)) {
+                    resolvedCompilerPath += ".exe";
+                } else {
+                    // Check again for a relative path.
+                    const relativePath: string = this.rootUri.fsPath + path.sep + resolvedCompilerPath;
+                    if (!fs.existsSync(relativePath)) {
+                        if (existsWithExeAdded(resolvedCompilerPath)) {
+                            resolvedCompilerPath += ".exe";
+                        } else {
+                            pathExists = false;
+                        }
+                    } else {
+                        resolvedCompilerPath = relativePath;
+                    }
+                }
+            }
+            
+            if (!pathExists) {
+                let message: string = `Cannot find: ${resolvedCompilerPath}`;
+                compilerPathErrors.push(message);
+            } else if (!util.checkFileExistsSync(resolvedCompilerPath)) {
+                let message: string = `Path is not a file: ${resolvedCompilerPath}`;
+                compilerPathErrors.push(message);
+            }
+
+            if (compilerPathErrors.length > 0) {
+                errors.compilerPath = compilerPathErrors.join('\n');
+            }
+        }
+
+        // Validate includePath
+        let includePathErrors: string[] = [];
+        if (this.CurrentConfiguration.includePath) {
+            for (let includePath of this.CurrentConfiguration.includePath) {
+                let pathExists: boolean = true;
+                let resolvedIncludePath: string = this.resolvePath(includePath, isWindows);
+                if (!resolvedIncludePath) {
+                    continue;
+                }
+
+                // Check if resolved path exists
+                if (!fs.existsSync(resolvedIncludePath)) {
+                    // Check for relative path if resolved path does not exists
+                    const relativePath: string = this.rootUri.fsPath + path.sep + resolvedIncludePath;
+                    if (!fs.existsSync(relativePath)) {
+                        pathExists = false;
+                    } else {
+                        resolvedIncludePath = relativePath;
+                    }
+                }
+
+                if (!pathExists) {
+                    let message: string = `Cannot find: ${resolvedIncludePath}`;
+                    includePathErrors.push(message);
+                    continue;
+                }
+
+                // Check if path is a directory
+                if (!util.checkDirectoryExistsSync(resolvedIncludePath)) {
+                    let message: string = `Path is not a directory: ${resolvedIncludePath}`;
+                    includePathErrors.push(message);
+                }
+            }
+
+            if (includePathErrors.length > 0) {
+                errors.includePath = includePathErrors.join('\n');
+            }
+        }
+
+        // Validate intelliSenseMode
+        if (isWindows && !this.isCompilerIntelliSenseModeCompatible()) {
+            errors.intelliSenseMode = `IntelliSense mode ${this.CurrentConfiguration.intelliSenseMode} is incompatible with compiler path.`;
+        }
+
+        return errors;
+    }
+
+    private handleSquiggles(): void {
+        if (!this.propertiesFile) {
+            return;
+        }
+
+        if (this.configurationJson.enableConfigurationSquiggles === false) {
+            this.diagnosticCollection.clear();
+            return;
+        }
+
+        const settings: CppSettings = new CppSettings(this.rootUri);
+        if (settings.defaultEnableConfigurationSquiggles === false) {
+            this.diagnosticCollection.clear();
+            return;
+        }
+
+        vscode.workspace.openTextDocument(this.propertiesFile).then((document: vscode.TextDocument) => {
+            let diagnostics: vscode.Diagnostic[] = new Array<vscode.Diagnostic>();
+
+            // Get the text of the current configuration.
+            let curText: string = document.getText();
+            let curTextStartOffset: number = 0;
+            if (!this.CurrentConfiguration.name) {
+                return;
+            }
+            const configStart: number = curText.search(new RegExp(`{\\s*"name"\\s*:\\s*"${escapeStringRegExp(this.CurrentConfiguration.name)}"`));
+            if (configStart === -1) {
+                telemetry.logLanguageServerEvent("ConfigSquiggles", { "error": "config name not first" });
+                return;
+            }
+            curTextStartOffset = configStart + 1;
+            curText = curText.substr(curTextStartOffset); // Remove earlier configs.
+            const nameEnd: number = curText.indexOf(":");
+            curTextStartOffset += nameEnd + 1;
+            curText = curText.substr(nameEnd + 1);
+            const nextNameStart: number = curText.search(new RegExp('"name"\\s*:\\s*"'));
+            if (nextNameStart !== -1) {
+                curText = curText.substr(0, nextNameStart + 6); // Remove later configs.
+                const nextNameStart2: number = curText.search(new RegExp('\\s*}\\s*,\\s*{\\s*"name"'));
+                if (nextNameStart2 === -1) {
+                    telemetry.logLanguageServerEvent("ConfigSquiggles", { "error": "next config name not first" });
+                    return;
+                }
+                curText = curText.substr(0, nextNameStart2);
+            }
+            if (this.prevSquiggleMetrics[this.CurrentConfiguration.name] === undefined) {
+                this.prevSquiggleMetrics[this.CurrentConfiguration.name] = { PathNonExistent: 0, PathNotAFile: 0, PathNotADirectory: 0, CompilerPathMissingQuotes: 0, CompilerModeMismatch: 0 };
+            }
+            let newSquiggleMetrics: { [key: string]: number } = { PathNonExistent: 0, PathNotAFile: 0, PathNotADirectory: 0, CompilerPathMissingQuotes: 0, CompilerModeMismatch: 0 };
+            const isWindows: boolean = os.platform() === 'win32';
+
+            // TODO: Add other squiggles.
+
+            // Check if intelliSenseMode and compilerPath are compatible
+            if (isWindows) {
+                // cl.exe is only available on Windows
+                const intelliSenseModeStart: number = curText.search(/\s*\"intelliSenseMode\"\s*:\s*\"/);
+                if (intelliSenseModeStart !== -1) {
+                    const intelliSenseModeValueStart: number = curText.indexOf('"', curText.indexOf(":", intelliSenseModeStart));
+                    const intelliSenseModeValueEnd: number = intelliSenseModeStart === -1 ? -1 : curText.indexOf('"', intelliSenseModeValueStart + 1) + 1;
+
+                    if (!this.isCompilerIntelliSenseModeCompatible()) {
+                        let message: string = `intelliSenseMode ${this.CurrentConfiguration.intelliSenseMode} is incompatible with compilerPath.`;
+                        let diagnostic: vscode.Diagnostic = new vscode.Diagnostic(
+                            new vscode.Range(document.positionAt(curTextStartOffset + intelliSenseModeValueStart),
+                                document.positionAt(curTextStartOffset + intelliSenseModeValueEnd)),
+                            message, vscode.DiagnosticSeverity.Warning);
+                        diagnostics.push(diagnostic);
+                        newSquiggleMetrics.CompilerModeMismatch++;
+                    }
+                }
+            }
+
+            // Check for path-related squiggles.
+            let paths: Set<string> = new Set<string>();
+            for (let pathArray of [ (this.CurrentConfiguration.browse ? this.CurrentConfiguration.browse.path : undefined),
+                    this.CurrentConfiguration.includePath, this.CurrentConfiguration.macFrameworkPath, this.CurrentConfiguration.forcedInclude ] ) {
+                if (pathArray) {
+                    for (let curPath of pathArray) {
+                        paths.add(`${curPath}`);
+                    }
+                }
+            }
+            if (this.CurrentConfiguration.compileCommands) {
+                paths.add(`${this.CurrentConfiguration.compileCommands}`);
+            }
+
+            if (this.CurrentConfiguration.compilerPath) {
+                // Unlike other cases, compilerPath may not start or end with " due to trimming of whitespace and the possibility of compiler args.
+                paths.add(`${this.CurrentConfiguration.compilerPath}`);
+            }
+
+            // Get the start/end for properties that are file-only.
+            const forcedIncludeStart: number = curText.search(/\s*\"forcedInclude\"\s*:\s*\[/);
+            const forcedeIncludeEnd: number = forcedIncludeStart === -1 ? -1 : curText.indexOf("]", forcedIncludeStart);
+            const compileCommandsStart: number = curText.search(/\s*\"compileCommands\"\s*:\s*\"/);
+            const compileCommandsEnd: number = compileCommandsStart === -1 ? -1 : curText.indexOf('"', curText.indexOf('"', curText.indexOf(":", compileCommandsStart)) + 1);
+            const compilerPathStart: number = curText.search(/\s*\"compilerPath\"\s*:\s*\"/);
+            const compilerPathEnd: number = compilerPathStart === -1 ? -1 : curText.indexOf('"', curText.indexOf('"', curText.indexOf(":", compilerPathStart)) + 1) + 1;
+
+            for (let curPath of paths) {
+                const isCompilerPath: boolean = curPath === this.CurrentConfiguration.compilerPath;
+                // Resolve special path cases.
+                if (curPath === "${default}") {
+                    // TODO: Add squiggles for when the C_Cpp.default.* paths are invalid.
+                    continue;
+                }
+
+                let resolvedPath: string = this.resolvePath(curPath, isWindows);
+                if (!resolvedPath) {
+                    continue;
+                }
+
+                // TODO: Invalid paths created from environment variables are not detected.
+
+                let compilerPathNeedsQuotes: boolean = false;
+                if (isCompilerPath) {
+                    resolvedPath = resolvedPath.trim();
+                    let compilerPathAndArgs: util.CompilerPathAndArgs = util.extractCompilerPathAndArgs(resolvedPath);
+                    if (isWindows && compilerPathAndArgs.compilerPath.endsWith("cl.exe")) {
+                        continue; // Don't squiggle invalid cl.exe paths because it could be for an older preview build.
+                    }
+                    // Squiggle when the compiler's path has spaces without quotes but args are used.
+                    compilerPathNeedsQuotes = compilerPathAndArgs.additionalArgs && !resolvedPath.startsWith('"') && compilerPathAndArgs.compilerPath.includes(" ");
+                    resolvedPath = compilerPathAndArgs.compilerPath;
+                }
+
+                const isWSL: boolean = isWindows && resolvedPath.startsWith("/");
+                let pathExists: boolean = true;
+                let existsWithExeAdded: (path: string) => boolean = (path: string) => {
+                    return isCompilerPath && isWindows && !isWSL && fs.existsSync(path + ".exe");
+                };
+                if (!fs.existsSync(resolvedPath)) {
+                    if (existsWithExeAdded(resolvedPath)) {
+                        resolvedPath += ".exe";
+                    } else {
+                        // Check again for a relative path.
+                        const relativePath: string = this.rootUri.fsPath + path.sep + resolvedPath;
+                        if (!fs.existsSync(relativePath)) {
+                            if (existsWithExeAdded(resolvedPath)) {
+                                resolvedPath += ".exe";
+                            } else {
+                                pathExists = false;
+                            }
+                        } else {
+                            resolvedPath = relativePath;
+                        }
+                    }
+                }
+
+                // Normalize path separators.
+                if (path.sep === "/") {
+                    resolvedPath = resolvedPath.replace(/\\/g, path.sep);
+                } else {
+                    resolvedPath = resolvedPath.replace(/\//g, path.sep);
+                }
+
+                // Iterate through the text and apply squiggles.
+
+                // Escape the path string for literal use in a regular expression
+                // Need to escape any quotes to match the original text
+                let escapedPath: string = curPath.replace(/\"/g, '\\\"');
+                escapedPath = escapedPath.replace(/[-\"\/\\^$*+?.()|[\]{}]/g, '\\$&');
+
+                // Create a pattern to search for the path with either a quote or semicolon immediately before and after,
+                // and extend that pattern to the next quote before and next quote after it.
+                let pattern: RegExp = new RegExp(`"[^"]*?(?<="|;)${escapedPath}(?="|;).*?"`);
+                let matches: string[] = curText.match(pattern);
+                if (matches) {
+                    let curOffset: number = 0;
+                    let endOffset: number = 0;
+                    for (let curMatch of matches) {
+                        curOffset = curText.substr(endOffset).search(pattern) + endOffset;
+                        endOffset = curOffset + curMatch.length;
+                        let message: string;
+                        if (!pathExists) {
+                            message = `Cannot find "${resolvedPath}".`;
+                            newSquiggleMetrics.PathNonExistent++;
+                        } else {
+                            // Check for file versus path mismatches.
+                            if ((curOffset >= forcedIncludeStart && curOffset <= forcedeIncludeEnd) ||
+                                (curOffset >= compileCommandsStart && curOffset <= compileCommandsEnd) ||
+                                (curOffset >= compilerPathStart && curOffset <= compilerPathEnd)) {
+                                if (compilerPathNeedsQuotes) {
+                                    message = `Compiler path with spaces and arguments is missing \\" around the path.`;
+                                    newSquiggleMetrics.CompilerPathMissingQuotes++;
+                                } else {
+                                    if (util.checkFileExistsSync(resolvedPath)) {
+                                        continue;
+                                    }
+                                    message = `Path is not a file: "${resolvedPath}".`;
+                                    newSquiggleMetrics.PathNotAFile++;
+                                }
+                            } else {
+                                if (util.checkDirectoryExistsSync(resolvedPath)) {
+                                    continue;
+                                }
+                                message = `Path is not a directory: "${resolvedPath}".`;
+                                newSquiggleMetrics.PathNotADirectory++;
+                            }
+                        }
+                        let diagnostic: vscode.Diagnostic = new vscode.Diagnostic(
+                            new vscode.Range(document.positionAt(curTextStartOffset + curOffset),
+                                document.positionAt(curTextStartOffset + endOffset)),
+                            message, vscode.DiagnosticSeverity.Warning);
+                        diagnostics.push(diagnostic);
+                    }
+                }
+            }
+            if (diagnostics.length !== 0) {
+                this.diagnosticCollection.set(document.uri, diagnostics);
+            } else {
+                this.diagnosticCollection.clear();
+            }
+
+            // Send telemetry on squiggle changes.
+            let changedSquiggleMetrics: { [key: string]: number } = {};
+            if (newSquiggleMetrics.PathNonExistent !== this.prevSquiggleMetrics[this.CurrentConfiguration.name].PathNonExistent) {
+                changedSquiggleMetrics.PathNonExistent = newSquiggleMetrics.PathNonExistent;
+            }
+            if (newSquiggleMetrics.PathNotAFile !== this.prevSquiggleMetrics[this.CurrentConfiguration.name].PathNotAFile) {
+                changedSquiggleMetrics.PathNotAFile = newSquiggleMetrics.PathNotAFile;
+            }
+            if (newSquiggleMetrics.PathNotADirectory !== this.prevSquiggleMetrics[this.CurrentConfiguration.name].PathNotADirectory) {
+                changedSquiggleMetrics.PathNotADirectory = newSquiggleMetrics.PathNotADirectory;
+            }
+            if (newSquiggleMetrics.CompilerPathMissingQuotes !== this.prevSquiggleMetrics[this.CurrentConfiguration.name].CompilerPathMissingQuotes) {
+                changedSquiggleMetrics.CompilerPathMissingQuotes = newSquiggleMetrics.CompilerPathMissingQuotes;
+            }
+            if (Object.keys(changedSquiggleMetrics).length > 0) {
+                telemetry.logLanguageServerEvent("ConfigSquiggles", null, changedSquiggleMetrics);
+            }
+            this.prevSquiggleMetrics[this.CurrentConfiguration.name] = newSquiggleMetrics;
+        });
     }
 
     private updateToVersion2(): void {
@@ -713,18 +1274,23 @@ export class CppProperties {
         }
     }
 
+    private writeToJson(): void {
+        console.assert(this.propertiesFile);
+        fs.writeFileSync(this.propertiesFile.fsPath, JSON.stringify(this.configurationJson, null, 4));
+    }
+
     public checkCppProperties(): void {
         // Check for change properties in case of file watcher failure.
         let propertiesFile: string = path.join(this.configFolder, "c_cpp_properties.json");
         fs.stat(propertiesFile, (err, stats) => {
             if (err) {
-                if (this.propertiesFile !== null) {
+                if (this.propertiesFile) {
                     this.propertiesFile = null; // File deleted.
                     this.resetToDefaultSettings(true);
                     this.handleConfigurationChange();
                 }
             } else if (stats.mtime > this.configFileWatcherFallbackTime) {
-                if (this.propertiesFile === null) {
+                if (!this.propertiesFile) {
                     this.propertiesFile = vscode.Uri.file(propertiesFile); // File created.
                 }
                 this.handleConfigurationChange();
@@ -738,5 +1304,7 @@ export class CppProperties {
 
         this.compileCommandFileWatchers.forEach((watcher: fs.FSWatcher) => watcher.close());
         this.compileCommandFileWatchers = []; //reset it
+
+        this.diagnosticCollection.dispose();
     }
 }

Extension/src/LanguageServer/extension.ts

@@ -14,14 +14,17 @@ import { UI, getUI } from './ui';
 import { Client } from './client';
 import { ClientCollection } from './clientCollection';
 import { CppSettings } from './settings';
-import { PersistentWorkspaceState } from './persistentState';
+import { PersistentWorkspaceState, PersistentState } from './persistentState';
 import { getLanguageConfig } from './languageConfig';
 import { getCustomConfigProviders } from './customProviders';
 import { PlatformInformation } from '../platform';
 import { Range } from 'vscode-languageclient';
 import { ChildProcess, spawn, execSync } from 'child_process';
 import * as tmp from 'tmp';
-import { getTargetBuildInfo } from '../githubAPI';
+import { getTargetBuildInfo, BuildInfo } from '../githubAPI';
+import * as configs from './configurations';
+import { PackageVersion } from '../packageVersion';
+import { getTemporaryCommandRegistrarInstance } from '../commands';
 
 let prevCrashFile: string;
 let clients: ClientCollection;
@@ -35,12 +38,19 @@ let realActivationOccurred: boolean = false;
 let tempCommands: vscode.Disposable[] = [];
 let activatedPreviously: PersistentWorkspaceState<boolean>;
 const insiderUpdateTimerInterval: number = 1000 * 60 * 60;
+let buildInfoCache: BuildInfo | null = null;
+const taskSourceStr: string = "C/C++";
+const cppInstallVsixStr: string = 'C/C++: Install vsix -- ';
+let taskProvider: vscode.Disposable;
+const intelliSenseDisabledError: string = "Do not activate the extension when IntelliSense is disabled.";
 
 /**
  * activate: set up the extension for language services
  */
 export function activate(activationEventOccurred: boolean): void {
-    console.log("activating extension");
+    if (realActivationOccurred) {
+        return; // Occurs if multiple delayed commands occur before the real commands are registered.
+    }
 
     // Activate immediately if an activation event occurred in the previous workspace session.
     // If onActivationEvent doesn't occur, it won't auto-activate next time.
@@ -50,8 +60,9 @@ export function activate(activationEventOccurred: boolean): void {
         realActivation();
     }
 
-    registerCommands();
-    tempCommands.push(vscode.workspace.onDidOpenTextDocument(d => onDidOpenTextDocument(d)));
+    if (tempCommands.length === 0) { // Only needs to be added once.
+        tempCommands.push(vscode.workspace.onDidOpenTextDocument(d => onDidOpenTextDocument(d)));
+    }
 
     // Check if an activation event has already occurred.
     if (activationEventOccurred) {
@@ -59,6 +70,21 @@ export function activate(activationEventOccurred: boolean): void {
         return;
     }
 
+    taskProvider = vscode.tasks.registerTaskProvider(taskSourceStr, {
+        provideTasks: () => {
+            return getBuildTasks(false);
+        },
+        resolveTask(task: vscode.Task): vscode.Task {
+            // Currently cannot implement because VS Code does not call this. Can implement custom output file directory when enabled.
+            return undefined;
+        }
+    });
+    vscode.tasks.onDidStartTask(event => {
+        if (event.execution.task.source === taskSourceStr) {
+            telemetry.logLanguageServerEvent('buildTaskStarted');
+        }
+    });
+
     // handle "workspaceContains:/.vscode/c_cpp_properties.json" activation event.
     if (vscode.workspace.workspaceFolders && vscode.workspace.workspaceFolders.length > 0) {
         for (let i: number = 0; i < vscode.workspace.workspaceFolders.length; ++i) {
@@ -82,6 +108,163 @@ export function activate(activationEventOccurred: boolean): void {
     }
 }
 
+export interface BuildTaskDefinition extends vscode.TaskDefinition {
+    compilerPath: string;
+}
+
+/**
+ * Generate tasks to build the current file based on the user's detected compilers, the user's compilerPath setting, and the current file's extension.
+ */
+export async function getBuildTasks(returnComplerPath: boolean): Promise<vscode.Task[]> {
+    const editor: vscode.TextEditor = vscode.window.activeTextEditor;
+    if (!editor) {
+        return [];
+    }
+
+    const fileExt: string = path.extname(editor.document.fileName);
+    if (!fileExt) {
+        return;
+    }
+
+    // Don't offer tasks for header files.
+    const fileExtLower: string = fileExt.toLowerCase();
+    const isHeader: boolean = !fileExt || [".hpp", ".hh", ".hxx", ".h", ".inl", ""].some(ext => fileExtLower === ext);
+    if (isHeader) {
+        return [];
+    }
+
+    // Don't offer tasks if the active file's extension is not a recognized C/C++ extension.
+    let fileIsCpp: boolean;
+    let fileIsC: boolean;
+    if (fileExt === ".C") { // ".C" file extensions are both C and C++.
+        fileIsCpp = true;
+        fileIsC = true;
+    } else {
+        fileIsCpp = [".cpp", ".cc", ".cxx", ".mm", ".ino"].some(ext => fileExtLower === ext);
+        fileIsC = fileExtLower === ".c";
+    }
+    if (!(fileIsCpp || fileIsC)) {
+        return [];
+    }
+
+    // Get a list of compilers found from the C++ side, then filter them based on the file type to get a reduced list appropriate
+    // for the active file, remove duplicate compiler names, then finally add the user's compilerPath setting.
+    let compilerPaths: string[];
+    const isWindows: boolean = os.platform() === 'win32';
+    let activeClient: Client;
+    try {
+        activeClient = getActiveClient();
+    } catch (e) {
+        if (!e || e.message !== intelliSenseDisabledError) {
+            console.error("Unknown error calling getActiveClient().");
+        }
+        return []; // Language service features may be disabled.
+    }
+    let userCompilerPath: string = await activeClient.getCompilerPath();
+    if (userCompilerPath) {
+        userCompilerPath = userCompilerPath.trim();
+        if (isWindows && userCompilerPath.startsWith("/")) { // TODO: Add WSL compiler support.
+            userCompilerPath = null;
+        } else {
+            userCompilerPath = userCompilerPath.replace(/\\\\/g, "\\");
+        }
+    }
+
+    let knownCompilers: configs.KnownCompiler[] = await activeClient.getKnownCompilers();
+    if (knownCompilers) {
+        knownCompilers = knownCompilers.filter(info => {
+            return ((fileIsCpp && !info.isC) || (fileIsC && info.isC)) &&
+                (!isWindows || !info.path.startsWith("/")); // TODO: Add WSL compiler support.
+        });
+        compilerPaths = knownCompilers.map<string>(info => { return info.path; });
+
+        let map: Map<string, string> = new Map<string, string>();
+        const insertOrAssignEntry: (compilerPath: string) => void = (compilerPath: string): void => {
+            let basename: string = compilerPath;
+            if (compilerPath === userCompilerPath) {
+                // Make sure the compiler args are not part of the basename.
+                const compilerPathAndArgs: util.CompilerPathAndArgs = util.extractCompilerPathAndArgs(compilerPath);
+                basename = compilerPathAndArgs.compilerPath;
+            }
+            basename = path.basename(basename);
+            map.set(basename, compilerPath);
+        };
+        compilerPaths.forEach(insertOrAssignEntry);
+
+        // Ensure that the user's compilerPath setting is used by inserting/assigning last.
+        if (userCompilerPath) {
+            insertOrAssignEntry(userCompilerPath);
+        }
+
+        compilerPaths = [...map.values()];
+    } else if (userCompilerPath) {
+        compilerPaths = [userCompilerPath];
+    }
+
+    if (!compilerPaths) {
+        // Don't prompt a message yet until we can make a data-based decision.
+        telemetry.logLanguageServerEvent('noCompilerFound');
+        // Display a message prompting the user to install compilers if none were found.
+        // const dontShowAgain: string = "Don't Show Again";
+        // const learnMore: string = "Learn More";
+        // const message: string = "No C/C++ compiler found on the system. Please install a C/C++ compiler to use the C/C++: build active file tasks.";
+
+        // let showNoCompilerFoundMessage: PersistentState<boolean> = new PersistentState<boolean>("CPP.showNoCompilerFoundMessage", true);
+        // if (showNoCompilerFoundMessage) {
+        //     vscode.window.showInformationMessage(message, learnMore, dontShowAgain).then(selection => {
+        //         switch (selection) {
+        //             case learnMore:
+        //                 const uri: vscode.Uri = vscode.Uri.parse(`https://go.microsoft.com/fwlink/?linkid=864631`);
+        //                 vscode.commands.executeCommand('vscode.open', uri);
+        //                 break;
+        //             case dontShowAgain:
+        //                 showNoCompilerFoundMessage.Value = false;
+        //                 break;
+        //             default:
+        //                 break;
+        //         }
+        //     });
+        // }
+        return [];
+    }
+
+    // Generate tasks.
+    return compilerPaths.map<vscode.Task>(compilerPath => {
+        // Handle compiler args in compilerPath.
+        let compilerPathAndArgs: util.CompilerPathAndArgs = util.extractCompilerPathAndArgs(compilerPath);
+        compilerPath = compilerPathAndArgs.compilerPath;
+        const filePath: string = path.join('${fileDirname}', '${fileBasenameNoExtension}');
+        const compilerPathBase: string = path.basename(compilerPath);
+        const taskName: string = compilerPathBase + " build active file";
+        const isCl: boolean = taskName.startsWith("cl.exe");
+        let args: string[] = isCl ? [ '/Zi', '/EHsc', '/Fe:', filePath + '.exe', '${file}'  ] : ['-g', '${file}', '-o', filePath + (isWindows ? '.exe' : '')];
+        if (compilerPathAndArgs.additionalArgs) {
+            args = args.concat(compilerPathAndArgs.additionalArgs);
+        }
+        const cwd: string = isCl ? "" : path.dirname(compilerPath);
+        const kind: BuildTaskDefinition = {
+            type: 'shell',
+            label: taskName,
+            command: isCl ? compilerPathBase : compilerPath,
+            args: args,
+            options: isCl ? undefined : {"cwd": cwd},
+            compilerPath: isCl ? compilerPathBase : compilerPath
+        };
+
+        const command: vscode.ShellExecution = new vscode.ShellExecution(compilerPath, [...args], { cwd: cwd });
+        const target: vscode.WorkspaceFolder = vscode.workspace.getWorkspaceFolder(clients.ActiveClient.RootUri);
+        let task: vscode.Task = new vscode.Task(kind, target, taskName, taskSourceStr, command, '$gcc');
+        task.definition = kind; // The constructor for vscode.Task will eat the definition. Reset it by reassigning.
+        task.group = vscode.TaskGroup.Build;
+
+        if (!returnComplerPath) {
+            delete task.definition.compilerPath;
+        }
+
+        return task;
+    });
+}
+
 function onDidOpenTextDocument(document: vscode.TextDocument): void {
     if (document.languageId === "c" || document.languageId === "cpp") {
         onActivationEvent();
@@ -106,7 +289,19 @@ function onActivationEvent(): void {
 
 function realActivation(): void {
     if (new CppSettings().intelliSenseEngine === "Disabled") {
-        throw new Error("Do not activate the extension when IntelliSense is disabled.");
+        throw new Error(intelliSenseDisabledError);
+    } else {
+        console.log("activating extension");
+        let checkForConflictingExtensions: PersistentState<boolean> = new PersistentState<boolean>("CPP." + util.packageJson.version + ".checkForConflictingExtensions", true);
+        if (checkForConflictingExtensions.Value) {
+            checkForConflictingExtensions.Value = false;
+            let clangCommandAdapterActive: boolean = vscode.extensions.all.some((extension: vscode.Extension<any>, index: number, array: vscode.Extension<any>[]): boolean => {
+                return extension.isActive && extension.id === "mitaki28.vscode-clang";
+            });
+            if (clangCommandAdapterActive) {
+                telemetry.logLanguageServerEvent("conflictingExtension");
+            }
+        }
     }
 
     realActivationOccurred = true;
@@ -135,9 +330,12 @@ function realActivation(): void {
     updateLanguageConfigurations();
 
     reportMacCrashes();
-
+    
     const settings: CppSettings = new CppSettings(clients.ActiveClient.RootUri);
-    if (settings.updateChannel === 'Insiders') {
+    
+    if (settings.updateChannel === 'Default') {
+        suggestInsidersChannel();
+    } else if (settings.updateChannel === 'Insiders') {
         insiderUpdateTimer = setInterval(checkAndApplyUpdate, insiderUpdateTimerInterval, settings.updateChannel);
         checkAndApplyUpdate(settings.updateChannel);
     }
@@ -168,7 +366,7 @@ function onDidChangeSettings(): void {
         } else if (newUpdateChannel === 'Insiders') {
             insiderUpdateTimer = setInterval(checkAndApplyUpdate, insiderUpdateTimerInterval);
         }
-
+        
         checkAndApplyUpdate(newUpdateChannel);
     }
 }
@@ -232,16 +430,26 @@ function onInterval(): void {
  * Install a VSIX package. This helper function will exist until VSCode offers a command to do so.
  * @param updateChannel The user's updateChannel setting.
  */
-async function installVsix(vsixLocation: string, updateChannel: string): Promise<void> {
+function installVsix(vsixLocation: string): Thenable<void> {
+    let userVersion: PackageVersion = new PackageVersion(vscode.version);
+
+    // 1.33.0 introduces workbench.extensions.installExtension.  1.32.3 was immediately prior.
+    let lastVersionWithoutInstallExtensionCommand: PackageVersion = new PackageVersion('1.32.3');
+    if (userVersion.isGreaterThan(lastVersionWithoutInstallExtensionCommand)) {
+        return vscode.commands.executeCommand('workbench.extensions.installExtension', vscode.Uri.file(vsixLocation));
+    }
+
     // Get the path to the VSCode command -- replace logic later when VSCode allows calling of
     // workbench.extensions.action.installVSIX from TypeScript w/o instead popping up a file dialog
     return PlatformInformation.GetPlatformInformation().then((platformInfo) => {
         const vsCodeScriptPath: string = function(platformInfo): string {
             if (platformInfo.platform === 'win32') {
                 const vsCodeBinName: string = path.basename(process.execPath);
-                let cmdFile: string; // Windows VS Code Insiders breaks VS Code naming conventions
+                let cmdFile: string; // Windows VS Code Insiders/Exploration breaks VS Code naming conventions
                 if (vsCodeBinName === 'Code - Insiders.exe') {
                     cmdFile = 'code-insiders.cmd';
+                } else if (vsCodeBinName === 'Code - Exploration.exe') {
+                    cmdFile = 'code-exploration.cmd';
                 } else {
                     cmdFile = 'code.cmd';
                 }
@@ -264,7 +472,38 @@ async function installVsix(vsixLocation: string, updateChannel: string): Promise
             return Promise.reject(new Error('Failed to find VS Code script'));
         }
 
-        // Install the VSIX
+        // 1.28.0 changes the CLI for making installations.  1.27.2 was immediately prior.
+        let oldVersion: PackageVersion = new PackageVersion('1.27.2');
+        if (userVersion.isGreaterThan(oldVersion)) {
+            return new Promise<void>((resolve, reject) => {
+                let process: ChildProcess;
+                try {
+                    process = spawn(vsCodeScriptPath, ['--install-extension', vsixLocation, '--force']);
+
+                    // Timeout the process if no response is sent back. Ensures this Promise resolves/rejects
+                    const timer: NodeJS.Timer = setTimeout(() => {
+                        process.kill();
+                        reject(new Error('Failed to receive response from VS Code script process for installation within 30s.'));
+                    }, 30000);
+
+                    process.on('exit', (code: number) => {
+                        clearInterval(timer);
+                        if (code !== 0) {
+                            reject(new Error(`VS Code script exited with error code ${code}`));
+                        } else {
+                            resolve();
+                        }
+                    });
+                    if (process.pid === undefined) {
+                        throw new Error();
+                    }
+                } catch (error) {
+                    reject(new Error('Failed to launch VS Code script process for installation'));
+                    return;
+                }
+            });
+        }
+
         return new Promise<void>((resolve, reject) => {
             let process: ChildProcess;
             try {
@@ -280,8 +519,8 @@ async function installVsix(vsixLocation: string, updateChannel: string): Promise
             // Timeout the process if no response is sent back. Ensures this Promise resolves/rejects
             const timer: NodeJS.Timer = setTimeout(() => {
                 process.kill();
-                reject(new Error('Failed to receive response from VS Code script process for installation within 10s.'));
-            }, 10000);
+                reject(new Error('Failed to receive response from VS Code script process for installation within 30s.'));
+            }, 30000);
 
             // If downgrading, the VS Code CLI will prompt whether the user is sure they would like to downgrade.
             // Respond to this by writing 0 to stdin (the option to override and install the VSIX package)
@@ -299,56 +538,99 @@ async function installVsix(vsixLocation: string, updateChannel: string): Promise
     });
 }
 
-/**
- * Query package.json and the GitHub API to determine whether the user should update, if so then install the update.
- * The update can be an upgrade or downgrade depending on the the updateChannel setting.
- * @param updateChannel The user's updateChannel setting.
- */
-async function checkAndApplyUpdate(updateChannel: string): Promise<void> {
-    // Wrap in new Promise to allow tmp.file callback to successfully resolve/reject
-    // as tmp.file does not do anything with the callback functions return value
-    const p: Promise<void> = new Promise<void>((resolve, reject) => {
-        getTargetBuildInfo(updateChannel).then(buildInfo => {
-            if (!buildInfo) {
-                resolve();
+async function suggestInsidersChannel(): Promise<void> {
+    let suggestInsiders: PersistentState<boolean> = new PersistentState<boolean>("CPP.suggestInsiders", true);
+
+    if (!suggestInsiders.Value) {
+        return;
+    }
+    let buildInfo: BuildInfo;
+    try {
+        buildInfo = await getTargetBuildInfo("Insiders");
+    } catch (error) {
+        console.log(`${cppInstallVsixStr}${error.message}`);
+        if (error.message.indexOf('/') !== -1 || error.message.indexOf('\\') !== -1) {
+            error.message = "Potential PII hidden";
+        }
+        telemetry.logLanguageServerEvent('suggestInsiders', { 'error': error.message, 'success': 'false' });
+    }
+    if (!buildInfo) {
+        return; // No need to update.
+    }
+    const message: string = `Insiders version ${buildInfo.name} is available. Would you like to switch to the Insiders channel and install this update?`;
+    const yes: string = "Yes";
+    const askLater: string = "Ask Me Later";
+    const dontShowAgain: string = "Don't Show Again";
+    let selection: string = await vscode.window.showInformationMessage(message, yes, askLater, dontShowAgain);
+    switch (selection) {
+        case yes:
+            // Cache buildInfo.
+            buildInfoCache = buildInfo;
+            // It will call onDidChangeSettings.
+            vscode.workspace.getConfiguration("C_Cpp").update("updateChannel", "Insiders", vscode.ConfigurationTarget.Global);
+            break;
+        case dontShowAgain:
+            suggestInsiders.Value = false;
+            break;
+        case askLater:
+            break;
+        default:
+            break;
+    }
+}
+
+function applyUpdate(buildInfo: BuildInfo): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+        tmp.file({postfix: '.vsix'}, async (err, vsixPath, fd, cleanupCallback) => {
+            if (err) {
+                reject(new Error('Failed to create vsix file'));
                 return;
             }
-
-            // Create a temporary file, download the VSIX to it, then install the VSIX
-            tmp.file({postfix: '.vsix'}, async (err, vsixPath, fd, cleanupCallback) => {
-                if (err) {
-                    reject(new Error('Failed to create vsix file'));
-                    return;
-                }
-
-                // Place in try/catch as the .catch call catches a rejection in downloadFileToDestination
-                // then the .catch call will return a resolved promise
-                // Thusly, the .catch call must also throw, as a return would simply return an unused promise
-                // instead of returning early from this function scope
+    
+            // Place in try/catch as the .catch call catches a rejection in downloadFileToDestination
+            // then the .catch call will return a resolved promise
+            // Thusly, the .catch call must also throw, as a return would simply return an unused promise
+            // instead of returning early from this function scope
+            let config: vscode.WorkspaceConfiguration = vscode.workspace.getConfiguration();
+            let originalProxySupport: string = config.inspect<string>('http.proxySupport').globalValue;
+            while (true) { // Might need to try again with a different http.proxySupport setting.
                 try {
-                    await util.downloadFileToDestination(buildInfo.downloadUrl, vsixPath)
-                        .catch(() => { throw new Error('Failed to download VSIX package'); });
-                    await installVsix(vsixPath, updateChannel)
-                        .catch((error: Error) => { throw error; });
-                } catch (error) {
-                    reject(error);
+                    await util.downloadFileToDestination(buildInfo.downloadUrl, vsixPath);
+                } catch {
+                    // Try again with the proxySupport to "off".
+                    if (originalProxySupport !== config.inspect<string>('http.proxySupport').globalValue) {
+                        config.update('http.proxySupport', originalProxySupport, true); // Reset the http.proxySupport.
+                        reject(new Error('Failed to download VSIX package with proxySupport off')); // Changing the proxySupport didn't help.
+                        return;
+                    }
+                    if (config.get('http.proxySupport') !== "off" && originalProxySupport !== "off") {
+                        config.update('http.proxySupport', "off", true);
+                        continue;
+                    }
+                    reject(new Error('Failed to download VSIX package'));
                     return;
                 }
-                clearInterval(insiderUpdateTimer);
-                const message: string =
-                    `The C/C++ Extension has been updated to version ${buildInfo.name}. Please reload the window for the changes to take effect.`;
-                util.promptReloadWindow(message);
-                telemetry.logLanguageServerEvent('installVsix', { 'success': 'true' });
-
-                resolve();
-            });
-        }, (error: Error) => {
-            // Handle getTargetBuildInfo rejection
-            reject(error);
+                if (originalProxySupport !== config.inspect<string>('http.proxySupport').globalValue) {
+                    config.update('http.proxySupport', originalProxySupport, true); // Reset the http.proxySupport.
+                    telemetry.logLanguageServerEvent('installVsix', { 'error': "Success with proxySupport off", 'success': 'true' });
+                }
+                break;
+            }
+            try {
+                await installVsix(vsixPath);
+            } catch (error) {
+                reject(error);
+                return;
+            }
+            clearInterval(insiderUpdateTimer);
+            const message: string =
+                `The C/C++ Extension has been updated to version ${buildInfo.name}. Please reload the window for the changes to take effect.`;
+            util.promptReloadWindow(message);
+            telemetry.logLanguageServerEvent('installVsix', { 'success': 'true' });
+            resolve();
         });
-    });
-    await p.catch((error: Error) => {
-        // Handle .then following getTargetBuildInfo rejection
+    }).catch(error => {
+        console.error(`${cppInstallVsixStr}${error.message}`);
         if (error.message.indexOf('/') !== -1 || error.message.indexOf('\\') !== -1) {
             error.message = "Potential PII hidden";
         }
@@ -356,11 +638,41 @@ async function checkAndApplyUpdate(updateChannel: string): Promise<void> {
     });
 }
 
+/**
+ * Query package.json and the GitHub API to determine whether the user should update, if so then install the update.
+ * The update can be an upgrade or downgrade depending on the the updateChannel setting.
+ * @param updateChannel The user's updateChannel setting.
+ */
+async function checkAndApplyUpdate(updateChannel: string): Promise<void> {
+    // If we have buildInfo cache, we should use it.
+    let buildInfo: BuildInfo | null = buildInfoCache;
+    // clear buildInfo cache.
+    buildInfoCache = null;
+    
+    if (!buildInfo) {
+        try {
+            buildInfo = await getTargetBuildInfo(updateChannel);
+        } catch (error) {
+            telemetry.logLanguageServerEvent('installVsix', { 'error': error.message, 'success': 'false' });
+        }
+    }
+    if (!buildInfo) {
+        return; // No need to update.
+    }
+    await applyUpdate(buildInfo);
+}
+
 /*********************************************
  * registered commands
  *********************************************/
+let commandsRegistered: boolean = false;
 
-function registerCommands(): void {
+export function registerCommands(): void {
+    if (commandsRegistered) {
+        return;
+    }
+    commandsRegistered = true;
+    getTemporaryCommandRegistrarInstance().clearTempCommands();
     disposables.push(vscode.commands.registerCommand('C_Cpp.Navigate', onNavigate));
     disposables.push(vscode.commands.registerCommand('C_Cpp.GoToDeclaration', onGoToDeclaration));
     disposables.push(vscode.commands.registerCommand('C_Cpp.PeekDeclaration', onPeekDeclaration));
@@ -368,10 +680,12 @@ function registerCommands(): void {
     disposables.push(vscode.commands.registerCommand('C_Cpp.ResetDatabase', onResetDatabase));
     disposables.push(vscode.commands.registerCommand('C_Cpp.ConfigurationSelect', onSelectConfiguration));
     disposables.push(vscode.commands.registerCommand('C_Cpp.ConfigurationProviderSelect', onSelectConfigurationProvider));
+    disposables.push(vscode.commands.registerCommand('C_Cpp.ConfigurationEditJSON', onEditConfigurationJSON));
+    disposables.push(vscode.commands.registerCommand('C_Cpp.ConfigurationEditUI', onEditConfigurationUI));
     disposables.push(vscode.commands.registerCommand('C_Cpp.ConfigurationEdit', onEditConfiguration));
     disposables.push(vscode.commands.registerCommand('C_Cpp.AddToIncludePath', onAddToIncludePath));
-    disposables.push(vscode.commands.registerCommand('C_Cpp.ToggleErrorSquiggles', onToggleSquiggles));
-    disposables.push(vscode.commands.registerCommand('C_Cpp.ToggleSnippets', onToggleSnippets));
+    disposables.push(vscode.commands.registerCommand('C_Cpp.EnableErrorSquiggles', onEnableSquiggles));
+    disposables.push(vscode.commands.registerCommand('C_Cpp.DisableErrorSquiggles', onDisableSquiggles));
     disposables.push(vscode.commands.registerCommand('C_Cpp.ToggleIncludeFallback', onToggleIncludeFallback));
     disposables.push(vscode.commands.registerCommand('C_Cpp.ToggleDimInactiveRegions', onToggleDimInactiveRegions));
     disposables.push(vscode.commands.registerCommand('C_Cpp.ShowReleaseNotes', onShowReleaseNotes));
@@ -379,6 +693,9 @@ function registerCommands(): void {
     disposables.push(vscode.commands.registerCommand('C_Cpp.ResumeParsing', onResumeParsing));
     disposables.push(vscode.commands.registerCommand('C_Cpp.ShowParsingCommands', onShowParsingCommands));
     disposables.push(vscode.commands.registerCommand('C_Cpp.TakeSurvey', onTakeSurvey));
+    disposables.push(vscode.commands.registerCommand('C_Cpp.LogDiagnostics', onLogDiagnostics));
+    disposables.push(vscode.commands.registerCommand('cpptools.activeConfigName', onGetActiveConfigName));
+    getTemporaryCommandRegistrarInstance().executeDelayedCommands();
 }
 
 function onNavigate(): void {
@@ -492,6 +809,26 @@ function onSelectConfigurationProvider(): void {
     }
 }
 
+function onEditConfigurationJSON(): void {
+    onActivationEvent();
+    telemetry.logLanguageServerEvent("SettingsCommand", { "palette": "json" }, null);
+    if (!isFolderOpen()) {
+        vscode.window.showInformationMessage('Open a folder first to edit configurations');
+    } else {
+        selectClient().then(client => client.handleConfigurationEditJSONCommand(), rejected => {});
+    }
+}
+
+function onEditConfigurationUI(): void {
+    onActivationEvent();
+    telemetry.logLanguageServerEvent("SettingsCommand", { "palette": "ui" }, null);
+    if (!isFolderOpen()) {
+        vscode.window.showInformationMessage('Open a folder first to edit configurations');
+    } else {
+        selectClient().then(client => client.handleConfigurationEditUICommand(), rejected => {});
+    }
+}
+
 function onEditConfiguration(): void {
     onActivationEvent();
     if (!isFolderOpen()) {
@@ -511,54 +848,20 @@ function onAddToIncludePath(path: string): void {
     }
 }
 
-function onToggleSquiggles(): void {
+function onEnableSquiggles(): void {
     onActivationEvent();
     // This only applies to the active client.
     let settings: CppSettings = new CppSettings(clients.ActiveClient.RootUri);
-    settings.toggleSetting("errorSquiggles", "Enabled", "Disabled");
+    settings.update<string>("errorSquiggles", "Enabled");
 }
 
-function onToggleSnippets(): void {
+function onDisableSquiggles(): void {
     onActivationEvent();
-
-    // This will apply to all clients as it's a global toggle. It will require a reload.
-    const snippetsCatName: string  = "Snippets";
-    let newPackageJson: any = util.getRawPackageJson();
-
-    if (newPackageJson.categories.findIndex(cat => cat === snippetsCatName) === -1) {
-        // Add the Snippet category and snippets node. 
-
-        newPackageJson.categories.push(snippetsCatName);
-        newPackageJson.contributes.snippets = [{"language": "cpp", "path": "./cpp_snippets.json"}, {"language": "c", "path": "./cpp_snippets.json"}];
-
-        fs.writeFile(util.getPackageJsonPath(), util.stringifyPackageJson(newPackageJson), () => {
-            showReloadPrompt("Reload Window to finish enabling C++ snippets");
-        });
-        
-    } else {
-        // Remove the category and snippets node.
-        let ndxCat: number = newPackageJson.categories.indexOf(snippetsCatName);
-        if (ndxCat !== -1) {
-            newPackageJson.categories.splice(ndxCat, 1);
-        }
-
-        delete newPackageJson.contributes.snippets;
-
-        fs.writeFile(util.getPackageJsonPath(), util.stringifyPackageJson(newPackageJson), () => {
-            showReloadPrompt("Reload Window to finish disabling C++ snippets");
-        });
-    }
+    // This only applies to the active client.
+    let settings: CppSettings = new CppSettings(clients.ActiveClient.RootUri);
+    settings.update<string>("errorSquiggles", "Disabled");
 }
 
-function showReloadPrompt(msg: string): void { 
-    let reload: string = "Reload"; 
-    vscode.window.showInformationMessage(msg, reload).then(value => { 
-       if (value === reload) { 
-          vscode.commands.executeCommand("workbench.action.reloadWindow"); 
-       } 
-    }); 
- } 
-
 function onToggleIncludeFallback(): void {
     onActivationEvent();
     // This only applies to the active client.
@@ -600,6 +903,15 @@ function onTakeSurvey(): void {
     vscode.commands.executeCommand('vscode.open', uri);
 }
 
+function onGetActiveConfigName(): Thenable<string> {
+    return clients.ActiveClient.getCurrentConfigName();
+}
+
+function onLogDiagnostics(): void {
+    onActivationEvent();
+    clients.ActiveClient.logDiagnostics();
+}
+
 function reportMacCrashes(): void {
     if (process.platform === "darwin") {
         prevCrashFile = "";
@@ -645,32 +957,67 @@ function reportMacCrashes(): void {
     }
 }
 
-function handleCrashFileRead(err: NodeJS.ErrnoException, data: string): void {
+function logCrashTelemetry(data: string): void {
     let crashObject: { [key: string]: string } = {};
+    crashObject["CrashingThreadCallStack"] = data;
+    telemetry.logLanguageServerEvent("MacCrash", crashObject, null);
+}
+
+function handleCrashFileRead(err: NodeJS.ErrnoException, data: string): void {
     if (err) {
-        crashObject["readFile: err.code"] = err.code;
-        telemetry.logLanguageServerEvent("MacCrash", crashObject, null);
-        return;
+        return logCrashTelemetry("readFile: " + err.code);
     }
-    let startCrash: number = data.indexOf(" Crashed:");
+
+    // Extract the crashing thread's call stack.
+    const crashStart: string = " Crashed:";
+    let startCrash: number = data.indexOf(crashStart);
     if (startCrash < 0) {
-        startCrash = 0;
+        return logCrashTelemetry("No crash start");
     }
+    startCrash += crashStart.length + 1; // Skip past crashStart.
     let endCrash: number = data.indexOf("Thread ", startCrash);
-    if (endCrash < startCrash) {
-        endCrash = data.length - 1;
+    if (endCrash < 0) {
+        endCrash = data.length - 1; // Not expected, but just in case.
+    }
+    if (endCrash <= startCrash) {
+        return logCrashTelemetry("No crash end");
     }
     data = data.substr(startCrash, endCrash - startCrash);
+    
+    // Get rid of the memory addresses (which breaks being able get a hit count for each crash call stack).
+    data = data.replace(/0x................ /g, "");
+    data = data.replace(/0x1........ \+ 0/g, "");
+
+    // Get rid of the process names on each line and just add it to the start.
+    const process1: string = "Microsoft.VSCode.CPP.IntelliSense.Msvc.darwin\t";
+    const process2: string = "Microsoft.VSCode.CPP.Extension.darwin\t";
+    if (data.includes(process1)) {
+        data = data.replace(new RegExp(process1, "g"), "");
+        data = process1 + "\n" + data;
+    } else if (data.includes(process2)) {
+        data = data.replace(new RegExp(process2, "g"), "");
+        data = process2 + "\n" + data;
+    } else {
+        return logCrashTelemetry("No process"); // Not expected, but just in case.
+    }
+
+    // Remove runtime lines because they can be different on different machines.
+    let lines: string[] = data.split("\n");
+    data = "";
+    lines.forEach((line: string) => {
+        if (!line.includes(".dylib") && !line.includes("???")) {
+            line = line.replace(/^\d+\s+/, ""); // Remove <numbers><spaces> from the start of the line.
+            line = line.replace(/std::__1::/g, "std::");  // __1:: is not helpful.
+            data += (line + "\n");
+        }
+    });
+    data = data.trimRight();
+
     if (data.length > 8192) { // The API has an 8k limit.
         data = data.substr(0, 8189) + "...";
     }
-    if (data.length < 2) {
-        return; // Don't send telemetry if there's no call stack.
-    }
-    // Get rid of the memory addresses (which breaks being able get a hit count for each crash call stack).
-    data = data.replace(/0x................ /g, "");
-    crashObject["CrashingThreadCallStack"] = data;
-    telemetry.logLanguageServerEvent("MacCrash", crashObject, null);
+
+    logCrashTelemetry(data);
 }
 
 export function deactivate(): Thenable<void> {
@@ -681,6 +1028,9 @@ export function deactivate(): Thenable<void> {
     disposables.forEach(d => d.dispose());
     languageConfigurations.forEach(d => d.dispose());
     ui.dispose();
+    if (taskProvider) {
+        taskProvider.dispose();
+    }
     return clients.dispose();
 }
 
@@ -700,4 +1050,4 @@ export function getActiveClient(): Client {
         realActivation();
     }
     return clients.ActiveClient;
-}
+}

Extension/src/LanguageServer/persistentState.ts

@@ -12,19 +12,24 @@ class PersistentStateBase<T> {
     private key: string;
     private defaultvalue: T;
     private state: vscode.Memento;
+    private curvalue: T;
 
     constructor(key: string, defaultValue: T, state: vscode.Memento) {
         this.key = key;
         this.defaultvalue = defaultValue;
         this.state = state;
+        this.curvalue = defaultValue;
     }
 
     public get Value(): T {
-        return this.state.get<T>(this.key, this.defaultvalue);
+        return this.state ? this.state.get<T>(this.key, this.defaultvalue) : this.curvalue;
     }
 
     public set Value(newValue: T) {
-        this.state.update(this.key, newValue);
+        if (this.state) {
+            this.state.update(this.key, newValue);
+        }
+        this.curvalue = newValue;
     }
 
     public get DefaultValue(): T {
@@ -35,13 +40,13 @@ class PersistentStateBase<T> {
 // Abstraction for global state that persists across activations but is not present in a settings file
 export class PersistentState<T> extends PersistentStateBase<T> {
     constructor(key: string, defaultValue: T) {
-        super(key, defaultValue, util.extensionContext.globalState);
+        super(key, defaultValue, util.extensionContext ? util.extensionContext.globalState : null);
     }
 }
 
 export class PersistentWorkspaceState<T> extends PersistentStateBase<T> {
     constructor(key: string, defaultValue: T) {
-        super(key, defaultValue, util.extensionContext.workspaceState);
+        super(key, defaultValue, util.extensionContext ? util.extensionContext.workspaceState : null);
     }
 }
 

Extension/src/LanguageServer/protocolFilter.ts

@@ -4,6 +4,7 @@
  * ------------------------------------------------------------------------------------------ */
 'use strict';
 
+import * as path from 'path';
 import { Middleware } from 'vscode-languageclient';
 import { ClientCollection } from './clientCollection';
 import { Client } from './client';
@@ -23,6 +24,14 @@ export function createProtocolFilter(me: Client, clients: ClientCollection): Mid
         didOpen: (document, sendMessage) => {
             if (clients.checkOwnership(me, document)) {
                 me.TrackedDocuments.add(document);
+
+                // Work around vscode treating ".C" as c, by adding this file name to file associations as cpp
+                if (document.uri.path.endsWith(".C")) {
+                    let fileName: string = path.basename(document.uri.fsPath);
+                    let mappingString: string = fileName + "@" + document.uri.fsPath;
+                    me.addFileAssociations(mappingString, false);
+                }
+
                 me.provideCustomConfiguration(document).then(() => {
                     sendMessage(document);
                 }, () => {
@@ -47,9 +56,14 @@ export function createProtocolFilter(me: Client, clients: ClientCollection): Mid
             }
         },
 
-        provideCompletionItem: invoke3,
+        provideCompletionItem: invoke4,
         resolveCompletionItem: invoke2,
-        provideHover: invoke3,
+        provideHover: (document, position, token, next: (document, position, token) => any) => {
+            if (clients.checkOwnership(me, document)) {
+                return me.requestWhenReady(() => next(document, position, token));
+            }
+            return null;
+        },
         provideSignatureHelp: invoke3,
         provideDefinition: invoke3,
         provideReferences: invoke4,

Extension/src/LanguageServer/settings.ts

@@ -36,8 +36,11 @@ export class CppSettings extends Settings {
     public get clangFormatSortIncludes(): string { return super.Section.get<string>("clang_format_sortIncludes"); }
     public get clangFormatOnSave(): string { return super.Section.get<string>("clang_format_formatOnSave"); }
     public get formatting(): string { return super.Section.get<string>("formatting"); }
+    public get suggestSnippets(): boolean { return super.Section.get<boolean>("suggestSnippets"); }
     public get intelliSenseEngine(): string { return super.Section.get<string>("intelliSenseEngine"); }
     public get intelliSenseEngineFallback(): string { return super.Section.get<string>("intelliSenseEngineFallback"); }
+    public get intelliSenseCachePath(): string { return super.Section.get<string>("intelliSenseCachePath"); }
+    public get intelliSenseCacheSize(): number { return super.Section.get<number>("intelliSenseCacheSize"); }
     public get errorSquiggles(): string { return super.Section.get<string>("errorSquiggles"); }
     public get dimInactiveRegions(): boolean { return super.Section.get<boolean>("dimInactiveRegions"); }
     public get inactiveRegionOpacity(): number { return super.Section.get<number>("inactiveRegionOpacity"); }
@@ -69,6 +72,7 @@ export class CppSettings extends Settings {
     public get defaultDatabaseFilename(): string { return super.Section.get<string>("default.browse.databaseFilename"); }
     public get defaultLimitSymbolsToIncludedHeaders(): boolean { return super.Section.get<boolean>("default.browse.limitSymbolsToIncludedHeaders"); }
     public get defaultSystemIncludePath(): string[] { return super.Section.get<string[]>("default.systemIncludePath"); }
+    public get defaultEnableConfigurationSquiggles(): boolean { return super.Section.get<boolean>("default.enableConfigurationSquiggles"); }
 
     public toggleSetting(name: string, value1: string, value2: string): void {
         let value: string = super.Section.get<string>(name);
@@ -89,10 +93,11 @@ export class OtherSettings {
         this.resource = resource;
     }
 
-    public get editorTabSize(): vscode.WorkspaceConfiguration { return vscode.workspace.getConfiguration("editor", this.resource).get("tabSize"); }
+    public get editorTabSize(): number { return vscode.workspace.getConfiguration("editor", this.resource).get<number>("tabSize"); }
     public get filesAssociations(): any { return vscode.workspace.getConfiguration("files", null).get("associations"); }
     public get filesExclude(): vscode.WorkspaceConfiguration { return vscode.workspace.getConfiguration("files", this.resource).get("exclude"); }
     public get searchExclude(): vscode.WorkspaceConfiguration { return vscode.workspace.getConfiguration("search", this.resource).get("exclude"); }
+    public get settingsEditor(): string { return vscode.workspace.getConfiguration("workbench.settings").get<string>("editor"); }
 
     public set filesAssociations(value: any) {
          vscode.workspace.getConfiguration("files", null).update("associations", value, vscode.ConfigurationTarget.Workspace);

Extension/src/LanguageServer/settingsPanel.ts

@@ -0,0 +1,223 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All Rights Reserved.
+ * See 'LICENSE' in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+
+import * as path from 'path';
+import * as fs from 'fs';
+import * as vscode from 'vscode';
+import * as util from '../common';
+import * as config from './configurations';
+
+// TODO: share ElementId between SettingsPanel and SettingsApp. Investigate why SettingsApp cannot import/export
+const elementId: { [key: string]: string } = {
+    activeConfig: "activeConfig",
+    compilerPath: "compilerPath",
+    intelliSenseMode: "intelliSenseMode", 
+    includePath: "includePath",
+    defines: "defines",
+    cStandard: "cStandard",
+    cppStandard: "cppStandard"
+};
+
+export class SettingsPanel {
+    private configValues: config.Configuration;
+    private isIntelliSenseModeDefined: boolean = false;
+    private settingsPanelActivated = new vscode.EventEmitter<void>();
+    private configValuesChanged = new vscode.EventEmitter<void>();
+    private panel: vscode.WebviewPanel;
+    private disposable: vscode.Disposable = undefined;
+    private disposablesPanel: vscode.Disposable = undefined;
+    private static readonly viewType: string = 'settingsPanel';
+    private static readonly title: string = 'C/C++ Configurations';
+
+    constructor() {
+        this.configValues = { name: undefined };
+        this.disposable = vscode.Disposable.from(
+            this.settingsPanelActivated,
+            this.configValuesChanged
+        );
+    }
+
+    public createOrShow(activeConfiguration: config.Configuration, errors: config.ConfigurationErrors): void {
+        const column: vscode.ViewColumn = vscode.window.activeTextEditor
+                ? vscode.window.activeTextEditor.viewColumn
+                : undefined;
+
+        // Show existing panel
+        if (this.panel) {
+            this.panel.reveal(column, false);
+            return;
+        }
+
+        // Create new panel
+        this.panel = vscode.window.createWebviewPanel(
+            SettingsPanel.viewType,
+            SettingsPanel.title,
+            column || vscode.ViewColumn.One,
+            {
+                enableCommandUris: true,
+                enableScripts: true,
+
+                // Restrict the webview to only loading content from these directories
+                localResourceRoots: [
+                    vscode.Uri.file(util.extensionPath), 
+                    vscode.Uri.file(path.join(util.extensionPath, 'ui')), 
+                    vscode.Uri.file(path.join(util.extensionPath, 'out', 'ui'))]
+            }
+        );
+
+        this.panel.iconPath = vscode.Uri.file(util.getExtensionFilePath("LanguageCCPP_color_128x.png"));
+
+        this.disposablesPanel = vscode.Disposable.from(
+            this.panel,
+            this.panel.onDidDispose(this.onPanelDisposed, this),
+            this.panel.onDidChangeViewState(this.onViewStateChanged, this),
+            this.panel.webview.onDidReceiveMessage(this.onMessageReceived, this),
+            vscode.window.onDidChangeWindowState(this.onWindowStateChanged, this)
+        );
+
+        this.panel.webview.html = this.getHtml();
+
+        this.updateWebview(activeConfiguration, errors);
+    }
+
+    public get SettingsPanelActivated(): vscode.Event<void> { 
+        return this.settingsPanelActivated.event;
+    }
+
+    public get ConfigValuesChanged(): vscode.Event<void> { 
+        return this.configValuesChanged.event;
+    }
+
+    public getLastValuesFromConfigUI(): config.Configuration {
+        return this.configValues;
+    }
+
+    public updateConfigUI(configuration: config.Configuration, errors: config.ConfigurationErrors): void {
+        if (this.panel) {
+            this.updateWebview(configuration, errors);
+        }
+    }
+
+    public updateErrors(errors: config.ConfigurationErrors): void {
+        if (this.panel) {
+            this.panel.webview.postMessage({ command: 'updateErrors', errors: errors});
+        }
+    }
+
+    public dispose(): void {
+        // Clean up resources
+        this.panel.dispose();
+
+        if (this.disposable) {
+            this.disposable.dispose();
+        }
+
+        if (this.disposablesPanel) { 
+            this.disposablesPanel.dispose(); 
+        }
+    }
+
+    private onPanelDisposed(): void {
+        if (this.disposablesPanel) { 
+            this.disposablesPanel.dispose(); 
+            this.panel = undefined;
+        }
+    }
+
+    private updateWebview(configuration: config.Configuration, errors: config.ConfigurationErrors): void {
+        this.configValues = Object.assign({}, configuration); // Copy configuration values
+        this.isIntelliSenseModeDefined = (this.configValues.intelliSenseMode !== undefined);
+        if (this.panel) {
+            // Send a message to the webview to update the values and errors
+           this.panel.webview.postMessage({ command: 'updateConfig', config: this.configValues});
+           this.panel.webview.postMessage({ command: 'updateErrors', errors: errors});
+        }
+    }
+
+    private onViewStateChanged(e: vscode.WebviewPanelOnDidChangeViewStateEvent): void {
+        if (e.webviewPanel.active) {
+            this.settingsPanelActivated.fire();
+        }
+    }
+
+    private onWindowStateChanged(e: vscode.WindowState): void {
+        if (e.focused) {
+            this.settingsPanelActivated.fire();
+        }
+    }
+
+    private onMessageReceived(message: any): void {
+        if (message === null) {
+            return;
+        }
+        switch (message.command) {
+            case 'change':
+                this.updateConfig(message);
+        }
+    }
+
+    private updateConfig(message: any): void {
+        let entries: string[];
+
+        switch (message.key) {
+            case elementId.activeConfig:
+                this.configValues.name = message.value;
+                break;
+            case elementId.compilerPath:
+                this.configValues.compilerPath = message.value;
+                break;
+            case elementId.includePath:
+                entries = message.value.split("\n");
+                this.configValues.includePath = entries.filter(e => e);
+                break;
+            case elementId.defines:
+                entries = message.value.split("\n");
+                this.configValues.defines = entries.filter(e => e);
+                break;
+            case elementId.intelliSenseMode:
+                if (message.value !== "${default}" || this.isIntelliSenseModeDefined) {
+                    this.configValues.intelliSenseMode = message.value;
+                } else {
+                    this.configValues.intelliSenseMode = undefined;
+                }
+                break;
+            case elementId.cStandard:
+                this.configValues.cStandard = message.value;
+                break;
+            case elementId.cppStandard:
+                this.configValues.cppStandard = message.value;
+                break;
+        }
+
+        this.configValuesChanged.fire();
+    }
+
+    private getHtml(): string {
+        let content: string | undefined;
+        content = fs.readFileSync(util.getExtensionFilePath("ui/settings.html")).toString();
+
+        content = content.replace(
+            /{{root}}/g, 
+            vscode.Uri.file(util.extensionPath)
+            .with({ scheme: 'vscode-resource' })
+            .toString());
+
+        content = content.replace(
+            /{{nonce}}/g, 
+            this.getNonce());
+
+        return content;
+    }
+
+    private getNonce(): string {
+        let nonce: string;
+        const possible: string = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        for (let i: number = 0; i < 32; i++) {
+            nonce += possible.charAt(Math.floor(Math.random() * possible.length));
+        }
+        return nonce;
+    }
+}

Extension/src/LanguageServer/settingsTracker.ts

@@ -160,7 +160,7 @@ export class SettingsTracker {
                     break;
                 }
                 default: {
-                    if (key === "clang_format_path" || key.startsWith("default.")) {
+                    if (key === "clang_format_path" || key === "intelliSenseCachePath" || key.startsWith("default.")) {
                         value = this.areEqual(val, settings.inspect(key).defaultValue) ? "<default>" : "..."; // Track whether it's being used, but nothing specific about it.
                     } else {
                         value = String(this.previousCppSettings[key]);

Extension/src/LanguageServer/ui.ts

@@ -171,7 +171,8 @@ export class UI {
         for (let i: number = 0; i < configurationNames.length; i++) {
             items.push({ label: configurationNames[i], description: "", index: i });
         }
-        items.push({ label: "Edit Configurations...", description: "", index: configurationNames.length });
+        items.push({ label: "Edit Configurations (UI)", description: "", index: configurationNames.length });
+        items.push({ label: "Edit Configurations (JSON)", description: "", index: configurationNames.length + 1 });
 
         return vscode.window.showQuickPick(items, options)
             .then(selection => (selection) ? selection.index : -1);

Extension/src/commands.ts

@@ -6,31 +6,35 @@
 
 import * as vscode from 'vscode';
 import * as LanguageServer from './LanguageServer/extension';
+import * as util from './common';
 
 class TemporaryCommandRegistrar {
     // Used to save/re-execute commands used before the extension has activated (e.g. delayed by dependency downloading).
     private delayedCommandsToExecute: Set<string>;
     private tempCommands: vscode.Disposable[]; // Need to save this to unregister/dispose the temporary commands.
-    private isLanguageServerDisabled: boolean;
+    private isLanguageServerDisabled: boolean = false;
+    private isActivationReady: boolean = false;
 
     private commandsToRegister: string[] = [
-        "C_Cpp.ConfigurationEdit",
+        "C_Cpp.ConfigurationEditJSON",
+        "C_Cpp.ConfigurationEditUI",
         "C_Cpp.ConfigurationSelect",
         "C_Cpp.ConfigurationProviderSelect",
         "C_Cpp.SwitchHeaderSource",
         "C_Cpp.Navigate",
         "C_Cpp.GoToDeclaration",
         "C_Cpp.PeekDeclaration",
-        "C_Cpp.ToggleErrorSquiggles",
+        "C_Cpp.EnableErrorSquiggles",
+        "C_Cpp.DisableErrorSquiggles",
         "C_Cpp.ToggleIncludeFallback",
         "C_Cpp.ToggleDimInactiveRegions",
-        "C_Cpp.ToggleSnippets",
         "C_Cpp.ShowReleaseNotes",
         "C_Cpp.ResetDatabase",
         "C_Cpp.PauseParsing",
         "C_Cpp.ResumeParsing",
         "C_Cpp.ShowParsingCommands",
-        "C_Cpp.TakeSurvey"
+        "C_Cpp.TakeSurvey",
+        "C_Cpp.LogDiagnostics"
     ];
 
     constructor() {
@@ -38,9 +42,11 @@ class TemporaryCommandRegistrar {
         this.delayedCommandsToExecute = new Set<string>();
 
         // Add temp commands that invoke the real commands after download/install is complete (preventing an error message)
-        this.commandsToRegister.forEach(command => {
-            this.registerTempCommand(command);
-        });
+        if (util.extensionContext) {
+            this.commandsToRegister.forEach(command => {
+                this.registerTempCommand(command);
+            });
+        }
     }
 
     public registerTempCommand(command: string): void {
@@ -50,6 +56,9 @@ class TemporaryCommandRegistrar {
                 return;
             }
             this.delayedCommandsToExecute.add(command);
+            if (this.isActivationReady) {
+                LanguageServer.activate(true);
+            }
         }));
     }
 
@@ -59,13 +68,18 @@ class TemporaryCommandRegistrar {
 
     public activateLanguageServer(): void {
         // Main activation code.
+        LanguageServer.activate(this.delayedCommandsToExecute.size > 0);
+        this.isActivationReady = true;
+    }
+    
+    public clearTempCommands(): void {
         this.tempCommands.forEach((command) => {
             command.dispose();
         });
         this.tempCommands = [];
+    }
 
-        LanguageServer.activate(this.delayedCommandsToExecute.size > 0);
-        
+    public executeDelayedCommands(): void {
         this.delayedCommandsToExecute.forEach((command) => {
             vscode.commands.executeCommand(command);
         });

Extension/src/common.ts

@@ -16,11 +16,20 @@ import { getOutputChannelLogger, showOutputChannel } from './logger';
 import * as assert from 'assert';
 import * as https from 'https';
 import { ClientRequest, OutgoingHttpHeaders } from 'http';
+import { getBuildTasks } from './LanguageServer/extension';
+import { OtherSettings } from './LanguageServer/settings';
 
+export let extensionPath: string;
 export let extensionContext: vscode.ExtensionContext;
 export function setExtensionContext(context: vscode.ExtensionContext): void {
     extensionContext = context;
+    extensionPath = extensionContext.extensionPath;
 }
+export function setExtensionPath(path: string): void {
+    extensionPath = path;
+}
+
+export const failedToParseTasksJson: string = "Failed to parse tasks.json, possibly due to comments or trailing commas.";
 
 // Use this package.json to read values
 export const packageJson: any = vscode.extensions.getExtension("ms-vscode.cpptools").packageJSON;
@@ -36,6 +45,64 @@ export function getRawPackageJson(): any {
     return rawPackageJson;
 }
 
+export function getRawTasksJson(): Promise<any> {
+    const path: string = getTasksJsonPath();
+    if (!path) {
+        return undefined;
+    }
+    return new Promise<any>((resolve, reject) => {
+        fs.exists(path, exists => {
+            if (!exists) {
+                return resolve({});
+            }
+            let fileContents: string = fs.readFileSync(path).toString();
+            fileContents = fileContents.replace(/^\s*\/\/.*$/gm, ""); // Remove start of line // comments.
+            let rawTasks: any = {};
+            try {
+                rawTasks = JSON.parse(fileContents); 
+            } catch (error) {
+                return reject(new Error(failedToParseTasksJson));
+            }
+            resolve(rawTasks);
+        });
+    });
+}
+
+export async function ensureBuildTaskExists(taskName: string): Promise<void> {
+    let rawTasksJson: any = await getRawTasksJson();
+
+    // Ensure that the task exists in the user's task.json. Task will not be found otherwise.
+    if (!rawTasksJson.tasks) {
+        rawTasksJson.tasks = new Array();
+    }
+    // Find or create the task which should be created based on the selected "debug configuration".
+    let selectedTask: vscode.Task = rawTasksJson.tasks.find(task => {
+        return task.label && task.label === task;
+    });
+    if (selectedTask) {
+        return;
+    }
+
+    const buildTasks: vscode.Task[] = await getBuildTasks(false);
+    selectedTask = buildTasks.find(task => task.name === taskName);
+    console.assert(selectedTask);
+
+    rawTasksJson.version = "2.0.0";
+
+    if (!rawTasksJson.tasks.find(task => { return task.label === selectedTask.definition.label; })) {
+        rawTasksJson.tasks.push(selectedTask.definition);
+    }
+    
+    // TODO: It's dangerous to overwrite this file. We could be wiping out comments.
+    let settings: OtherSettings = new OtherSettings();
+    await writeFileText(getTasksJsonPath(), JSON.stringify(rawTasksJson, null, settings.editorTabSize));
+}
+
+export function fileIsCOrCppSource(file: string): boolean {
+    const fileExtLower: string = path.extname(file).toLowerCase();
+    return [".C", ".c", ".cpp", ".cc", ".cxx", ".mm", ".ino", ".inl"].some(ext => fileExtLower === ext);
+}
+
 // This function is used to stringify the rawPackageJson.
 // Do not use with util.packageJson or else the expanded
 // package.json will be written back.
@@ -44,13 +111,22 @@ export function stringifyPackageJson(packageJson: string): string {
 }
 
 export function getExtensionFilePath(extensionfile: string): string {
-    return path.resolve(extensionContext.extensionPath, extensionfile);
+    return path.resolve(extensionPath, extensionfile);
 }
 
 export function getPackageJsonPath(): string {
     return getExtensionFilePath("package.json");
 }
 
+export function getTasksJsonPath(): string {
+    const editor: vscode.TextEditor = vscode.window.activeTextEditor;
+    const folder: vscode.WorkspaceFolder = vscode.workspace.getWorkspaceFolder(editor.document.uri);
+    if (!folder) {
+        return undefined;
+    }
+    return path.join(folder.uri.fsPath, ".vscode", "tasks.json");
+}
+
 export function getVcpkgPathDescriptorFile(): string {
     if (process.platform === 'win32') {
         return path.join(process.env.LOCALAPPDATA, "vcpkg/vcpkg.path.txt");
@@ -80,8 +156,8 @@ export function getVcpkgRoot(): string {
  * For the purposes of this function, a header file has no extension, or an extension that begins with the letter 'h'.
  * @param document The document to check.
  */
-export function isHeader(document: vscode.TextDocument): boolean {
-    let ext: string = path.extname(document.uri.fsPath);
+export function isHeader(uri: vscode.Uri): boolean {
+    let ext: string = path.extname(uri.fsPath);
     return !ext || ext.startsWith(".h") || ext.startsWith(".H");
 }
 
@@ -124,15 +200,15 @@ let installProgressStr: string = "CPP." + packageJson.version + ".Progress";
 let intelliSenseProgressStr: string = "CPP." + packageJson.version + ".IntelliSenseProgress";
 
 export function getProgress(): number {
-    return extensionContext.globalState.get<number>(installProgressStr, -1);
+    return extensionContext ? extensionContext.globalState.get<number>(installProgressStr, -1) : -1;
 }
 
 export function getIntelliSenseProgress(): number {
-    return extensionContext.globalState.get<number>(intelliSenseProgressStr, -1);
+    return extensionContext ? extensionContext.globalState.get<number>(intelliSenseProgressStr, -1) : -1;
 }
 
 export function setProgress(progress: number): void {
-    if (getProgress() < progress) {
+    if (extensionContext && getProgress() < progress) {
         extensionContext.globalState.update(installProgressStr, progress);
         let telemetryProperties: { [key: string]: string } = {};
         let progressName: string;
@@ -149,7 +225,7 @@ export function setProgress(progress: number): void {
 }
 
 export function setIntelliSenseProgress(progress: number): void {
-    if (getIntelliSenseProgress() < progress) {
+    if (extensionContext && getIntelliSenseProgress() < progress) {
         extensionContext.globalState.update(intelliSenseProgressStr, progress);
         let telemetryProperties: { [key: string]: string } = {};
         let progressName: string;
@@ -167,8 +243,16 @@ export function getProgressExecutableSuccess(): number { return progressExecutab
 export function getProgressParseRootSuccess(): number { return progressParseRootSuccess; } // Parse root was successful (i.e. not blocked by processing taking too long).
 export function getProgressIntelliSenseNoSquiggles(): number { return progressIntelliSenseNoSquiggles; } // IntelliSense was successful and the user got no squiggles.
 
-export function showReleaseNotes(): void {
-    vscode.commands.executeCommand('vscode.previewHtml', vscode.Uri.file(getExtensionFilePath("ReleaseNotes.html")), vscode.ViewColumn.One, "C/C++ Extension Release Notes");
+let releaseNotesPanel: vscode.WebviewPanel = undefined;
+
+export async function showReleaseNotes(): Promise<void> {
+    if (releaseNotesPanel) {
+        releaseNotesPanel.reveal();
+    } else {
+        releaseNotesPanel = vscode.window.createWebviewPanel('releaseNotes', "C/C++ Extension Release Notes", vscode.ViewColumn.One);
+        releaseNotesPanel.webview.html = await readFileText(getExtensionFilePath("ReleaseNotes.html"));
+        releaseNotesPanel.onDidDispose(() => releaseNotesPanel = undefined, null, extensionContext.subscriptions);
+    }
 }
 
 export function isUri(input: any): input is vscode.Uri {
@@ -342,7 +426,7 @@ export function touchInstallLockFile(): Promise<void> {
 
 export function touchExtensionFolder(): Promise<void> {
     return new Promise<void>((resolve, reject) => {
-        fs.utimes(path.resolve(extensionContext.extensionPath, ".."), new Date(Date.now()), new Date(Date.now()), (err) => {
+        fs.utimes(path.resolve(extensionPath, ".."), new Date(Date.now()), new Date(Date.now()), (err) => {
             if (err) {
                 reject(err);
             }
@@ -378,6 +462,23 @@ export function checkDirectoryExists(dirPath: string): Promise<boolean> {
     });
 }
 
+export function checkFileExistsSync(filePath: string): boolean {
+    try {
+        return fs.statSync(filePath).isFile();
+    } catch (e) {
+    }
+    return false;
+}
+
+/** Test whether a directory exists */
+export function checkDirectoryExistsSync(dirPath: string): boolean {
+    try {
+        return fs.statSync(dirPath).isDirectory();
+    } catch (e) {
+    }
+    return false;
+}
+
 /** Read the files in a directory */
 export function readDir(dirPath: string): Promise<string[]> {
     return new Promise((resolve) => {
@@ -622,10 +723,10 @@ export function downloadFileToDestination(urlStr: string, destinationPath: strin
             // Write file using downloaded data
             let createdFile: fs.WriteStream = fs.createWriteStream(destinationPath);
             createdFile.on('finish', () => { resolve(); });
-            response.on('error', (error) => { reject(); });
+            response.on('error', (error) => { reject(error); });
             response.pipe(createdFile);
         });
-        request.on('error', (error) => { reject(); });
+        request.on('error', (error) => { reject(error); });
         request.end();
     });
 }
@@ -655,10 +756,84 @@ export function downloadFileToStr(urlStr: string, headers?: OutgoingHttpHeaders)
             }
             let downloadedData: string = '';
             response.on('data', (data) => { downloadedData += data; });
-            response.on('error', (error) => { reject(); });
+            response.on('error', (error) => { reject(error); });
             response.on('end', () => { resolve(downloadedData); });
         });
-        request.on('error', (error) => { reject(); });
+        request.on('error', (error) => { reject(error); });
         request.end();
     });
-}
+}
+
+export interface CompilerPathAndArgs {
+    compilerPath: string;
+    additionalArgs: string[];
+}
+
+export function extractCompilerPathAndArgs(inputCompilerPath: string): CompilerPathAndArgs {
+    let compilerPath: string = inputCompilerPath;
+    let additionalArgs: string[];
+    let isWindows: boolean = os.platform() === 'win32';
+    if (compilerPath) {
+        if (compilerPath.startsWith("\"")) {
+            let endQuote: number = compilerPath.substr(1).search("\"") + 1;
+            if (endQuote !== -1) {
+                additionalArgs = compilerPath.substr(endQuote + 1).split(" ");
+                additionalArgs = additionalArgs.filter((arg: string) => { return arg.trim().length !== 0; }); // Remove empty args.
+                compilerPath = compilerPath.substr(1, endQuote - 1);
+            }
+        } else {
+            // Go from right to left checking if a valid path is to the left of a space.
+            let spaceStart: number = compilerPath.lastIndexOf(" ");
+            if (spaceStart !== -1 && (!isWindows || !compilerPath.endsWith("cl.exe")) && !checkFileExistsSync(compilerPath)) {
+                let potentialCompilerPath: string = compilerPath.substr(0, spaceStart);
+                while ((!isWindows || !potentialCompilerPath.endsWith("cl.exe")) && !checkFileExistsSync(potentialCompilerPath)) {
+                    spaceStart = potentialCompilerPath.lastIndexOf(" ");
+                    if (spaceStart === -1) {
+                        // Reached the start without finding a valid path. Use the original value.
+                        potentialCompilerPath = compilerPath;
+                        break;
+                    }
+                    potentialCompilerPath = potentialCompilerPath.substr(0, spaceStart);
+                }
+                if (compilerPath !== potentialCompilerPath) {
+                    // Found a valid compilerPath and args.
+                    additionalArgs = compilerPath.substr(spaceStart + 1).split(" ");
+                    additionalArgs = additionalArgs.filter((arg: string) => { return arg.trim().length !== 0; }); // Remove empty args.
+                    compilerPath = potentialCompilerPath;
+                }
+            }
+        }
+    }
+    return { compilerPath, additionalArgs };
+}
+
+export function escapeForSquiggles(s: string): string {
+    // Replace all \<escape character> with \\<character>, except for \"
+    // Otherwise, the JSON.parse result will have the \<escape character> missing.
+    let newResults: string = "";
+    let lastWasBackslash: Boolean = false;
+    let lastBackslashWasEscaped: Boolean = false;
+    for (let i: number = 0; i < s.length; i++) {
+        if (s[i] === '\\') {
+            if (lastWasBackslash) {
+                newResults += "\\";
+                lastBackslashWasEscaped = !lastBackslashWasEscaped;
+            } else {
+                lastBackslashWasEscaped = false;
+            }
+            newResults += "\\";
+            lastWasBackslash = true;
+        } else {
+            if (lastWasBackslash && (lastBackslashWasEscaped || (s[i] !== '"'))) {
+                newResults += "\\";
+            }
+            lastWasBackslash = false;
+            lastBackslashWasEscaped  = false;
+            newResults += s[i];
+        }
+    }
+    if (lastWasBackslash) {
+        newResults += "\\";
+    }
+    return newResults;
+}

Extension/src/githubAPI.ts

@@ -9,6 +9,8 @@ import * as util from './common';
 import { PlatformInformation } from './platform';
 import { OutgoingHttpHeaders } from 'http';
 
+const testingInsidersVsixInstall: boolean = false; // Change this to true to enable testing of the Insiders vsix installation.
+
 /**
  * The object representation of a Build Asset. Each Asset corresponds to information about a release file on GitHub.
  */
@@ -139,7 +141,7 @@ export async function getTargetBuildInfo(updateChannel: string): Promise<BuildIn
             // Allows testing pre-releases without accidentally downgrading to the latest version
             const userVersion: PackageVersion = new PackageVersion(util.packageJson.version);
             const latestVersion: PackageVersion = new PackageVersion(builds[0].name);
-            if (userVersion.isGreaterThan(latestVersion) || (userVersion.suffix && userVersion.suffix !== 'insiders')) {
+            if (!testingInsidersVsixInstall && (userVersion.isGreaterThan(latestVersion) || (userVersion.suffix && userVersion.suffix !== 'insiders'))) {
                 return undefined;
             }
 
@@ -172,7 +174,7 @@ function getTargetBuild(builds: Build[], userVersion: PackageVersion, updateChan
     let needsUpdate: (installed: PackageVersion, target: PackageVersion) => boolean;
     let useBuild: (build: Build) => boolean;
     if (updateChannel === 'Insiders') {
-        needsUpdate = (installed: PackageVersion, target: PackageVersion) => { return target.isGreaterThan(installed); };
+        needsUpdate = (installed: PackageVersion, target: PackageVersion) => { return testingInsidersVsixInstall || target.isGreaterThan(installed); };
         useBuild = (build: Build): boolean => { return true; };
     } else if (updateChannel === 'Default') {
         needsUpdate = function(installed: PackageVersion, target: PackageVersion): boolean { return installed.isGreaterThan(target); };
@@ -189,7 +191,10 @@ function getTargetBuild(builds: Build[], userVersion: PackageVersion, updateChan
 
     // Check current version against target's version to determine if the installation should happen
     const targetVersion: PackageVersion = new PackageVersion(targetBuild.name);
-    return needsUpdate(userVersion, targetVersion) ? targetBuild : undefined;
+    if (needsUpdate(userVersion, targetVersion)) {
+        return targetBuild;
+    }
+    return undefined;
 }
 
 interface Rate {
@@ -201,7 +206,7 @@ interface RateLimit {
 }
 
 function isRate(input: any): input is Rate {
-    return input && input.remaining && util.isNumber(input.remaining);
+    return input && util.isNumber(input.remaining);
 }
 
 function isRateLimit(input: any): input is RateLimit {
@@ -211,7 +216,15 @@ function isRateLimit(input: any): input is RateLimit {
 async function getRateLimit(): Promise<RateLimit> {
     const header: OutgoingHttpHeaders = { 'User-Agent': 'vscode-cpptools' };
     const data: string = await util.downloadFileToStr('https://api.github.com/rate_limit', header)
-        .catch(() => { throw new Error('Failed to download rate limit JSON'); });
+        .catch((error) => {
+            if (error && error.code && error.code !== "ENOENT") {
+                // Only throw if the user is connected to the Internet.
+                throw new Error('Failed to download rate limit JSON');
+            }
+        });
+    if (!data) {
+        return Promise.resolve(null);
+    }
 
     let rateLimit: any;
     try {
@@ -229,7 +242,7 @@ async function getRateLimit(): Promise<RateLimit> {
 
 async function rateLimitExceeded(): Promise<boolean> {
     const rateLimit: RateLimit = await getRateLimit();
-    return rateLimit.rate.remaining <= 0;
+    return rateLimit && rateLimit.rate.remaining <= 0;
 }
 
 /**
@@ -246,7 +259,15 @@ async function getReleaseJson(): Promise<Build[]> {
     const header: OutgoingHttpHeaders = { 'User-Agent': 'vscode-cpptools' };
 
     const data: string = await util.downloadFileToStr(releaseUrl, header)
-        .catch(() => { throw new Error('Failed to download release JSON'); });
+        .catch((error) => {
+            if (error && error.code && error.code !== "ENOENT") {
+                // Only throw if the user is connected to the Internet.
+                throw new Error('Failed to download release JSON');
+            }
+        });
+    if (!data) {
+        return Promise.resolve(null);
+    }
 
     // Parse the file
     let releaseJson: any;

Extension/src/installationInformation.ts

@@ -3,8 +3,14 @@
  * See 'LICENSE' in the project root for license information.
  * ------------------------------------------------------------------------------------------ */
 
+export enum InstallationType {
+    Online,
+    Offline
+}
+
 export class InstallationInformation {
     stage: string;
+    type: InstallationType;
     hasError: boolean;
     telemetryProperties: { [key: string]: string };
 
@@ -25,4 +31,8 @@ export function getInstallationInformation(): InstallationInformation {
 
 export function setInstallationStage(stage: string): void {
     getInstallationInformation().stage = stage;
+}
+
+export function setInstallationType(type: InstallationType): void {
+    getInstallationInformation().type = type;
 }

Extension/src/main.ts

@@ -18,24 +18,24 @@ import { getTemporaryCommandRegistrarInstance, initializeTemporaryCommandRegistr
 import { PlatformInformation } from './platform';
 import { PackageManager, PackageManagerError, IPackage } from './packageManager';
 import { PersistentState } from './LanguageServer/persistentState';
-import { getInstallationInformation, InstallationInformation, setInstallationStage } from './installationInformation';
+import { getInstallationInformation, InstallationInformation, setInstallationStage, setInstallationType, InstallationType } from './installationInformation';
 import { Logger, getOutputChannelLogger, showOutputChannel } from './logger';
 import { CppTools1 } from './cppTools1';
 
-const releaseNotesVersion: number = 3;
+const releaseNotesVersion: number = 5;
 const cppTools: CppTools1 = new CppTools1();
 let languageServiceDisabled: boolean = false;
 let reloadMessageShown: boolean = false;
 let disposables: vscode.Disposable[] = [];
 
 export async function activate(context: vscode.ExtensionContext): Promise<CppToolsApi & CppToolsExtension> {
-    initializeTemporaryCommandRegistrar();
     util.setExtensionContext(context);
+    initializeTemporaryCommandRegistrar();
     Telemetry.activate();
     util.setProgress(0);
 
     // Initialize the DebuggerExtension and register the related commands and providers.
-    DebuggerExtension.initialize();
+    DebuggerExtension.initialize(context);
 
     await processRuntimeDependencies();
 
@@ -87,6 +87,7 @@ async function processRuntimeDependencies(): Promise<void> {
 
 async function offlineInstallation(): Promise<void> {
     setInstallationStage('getPlatformInfo');
+    setInstallationType(InstallationType.Offline);
     const info: PlatformInformation = await PlatformInformation.GetPlatformInformation();
 
     setInstallationStage('makeBinariesExecutable');
@@ -107,6 +108,7 @@ async function offlineInstallation(): Promise<void> {
 
 async function onlineInstallation(): Promise<void> {
     setInstallationStage('getPlatformInfo');
+    setInstallationType(InstallationType.Online);
     const info: PlatformInformation = await PlatformInformation.GetPlatformInformation();
 
     await downloadAndInstallPackages(info);
@@ -234,6 +236,7 @@ function sendTelemetry(info: PlatformInformation): boolean {
     const success: boolean = !installBlob.hasError;
 
     installBlob.telemetryProperties['success'] = success.toString();
+    installBlob.telemetryProperties['type'] = installBlob.type === InstallationType.Online ? "online" : "offline";
 
     if (info.distribution) {
         installBlob.telemetryProperties['linuxDistroName'] = info.distribution.name;
@@ -244,7 +247,9 @@ function sendTelemetry(info: PlatformInformation): boolean {
         util.setProgress(util.getProgressInstallSuccess());
         let versionShown: PersistentState<number> = new PersistentState<number>("CPP.ReleaseNotesVersion", -1);
         if (versionShown.Value < releaseNotesVersion) {
-            util.showReleaseNotes();
+            if (versionShown.Value !== versionShown.DefaultValue) {
+                util.showReleaseNotes();
+            }
             versionShown.Value = releaseNotesVersion;
         }
     }
@@ -299,7 +304,7 @@ async function finalizeExtensionActivation(): Promise<void> {
     // (this may result in rewriting the package.json file)
     
     let packageJsonPath: string = util.getExtensionFilePath("package.json");
-    if (!packageJsonPath.includes(".vscode-insiders")) {
+    if (!packageJsonPath.includes(".vscode-insiders") && !packageJsonPath.includes(".vscode-exploration")) {
         let abTestSettings: cpptoolsJsonUtils.ABTestSettings = cpptoolsJsonUtils.getABTestSettings();
         let packageJson: any = util.getRawPackageJson();
         let prevIntelliSenseEngineDefault: any = packageJson.contributes.configuration.properties["C_Cpp.intelliSenseEngine"].default;
@@ -329,23 +334,26 @@ function rewriteManifest(): Promise<void> {
         "onLanguage:c",
         "onCommand:extension.pickNativeProcess",
         "onCommand:extension.pickRemoteNativeProcess",
-        "onCommand:C_Cpp.ConfigurationEdit",
+        "onCommand:C_Cpp.BuildAndDebugActiveFile",
+        "onCommand:C_Cpp.ConfigurationEditJSON",
+        "onCommand:C_Cpp.ConfigurationEditUI",
         "onCommand:C_Cpp.ConfigurationSelect",
         "onCommand:C_Cpp.ConfigurationProviderSelect",
         "onCommand:C_Cpp.SwitchHeaderSource",
         "onCommand:C_Cpp.Navigate",
         "onCommand:C_Cpp.GoToDeclaration",
         "onCommand:C_Cpp.PeekDeclaration",
-        "onCommand:C_Cpp.ToggleErrorSquiggles",
+        "onCommand:C_Cpp.EnableErrorSquiggles",
+        "onCommand:C_Cpp.DisableErrorSquiggles",
         "onCommand:C_Cpp.ToggleIncludeFallback",
         "onCommand:C_Cpp.ToggleDimInactiveRegions",
-        "onCommand:C_Cpp.ToggleSnippets",
         "onCommand:C_Cpp.ShowReleaseNotes",
         "onCommand:C_Cpp.ResetDatabase",
         "onCommand:C_Cpp.PauseParsing",
         "onCommand:C_Cpp.ResumeParsing",
         "onCommand:C_Cpp.ShowParsingCommands",
         "onCommand:C_Cpp.TakeSurvey",
+        "onCommand:C_Cpp.LogDiagnostics",
         "onDebug",
         "workspaceContains:/.vscode/c_cpp_properties.json"
     ];

Extension/src/packageVersion.ts

@@ -40,9 +40,8 @@ export class PackageVersion {
         }
     }
 
-    public isGreaterThan(other: PackageVersion): boolean {
-        // PackageVersions cannot be compared if either have a suffix that is not 'insiders'
-        if ((this.suffix && !this.suffix.startsWith('insiders')) || (other.suffix && !other.suffix.startsWith('insiders'))) {
+    public isGreaterThan(other: PackageVersion, suffixStr: string = 'insiders'): boolean {
+        if ((this.suffix && !this.suffix.startsWith(suffixStr)) || (other.suffix && !other.suffix.startsWith(suffixStr))) {
             return false;
         }
 

Extension/src/platform.ts

@@ -39,7 +39,7 @@ export class PlatformInformation {
     public static GetUnknownArchitecture(): string { return "Unknown"; }
 
     private static GetWindowsArchitecture(): Promise<string> {
-        return util.execChildProcess('wmic os get osarchitecture', util.extensionContext.extensionPath)
+        return util.execChildProcess('wmic os get osarchitecture', util.extensionPath)
             .then((architecture) => {
                 if (architecture) {
                     let archArray: string[] = architecture.split(os.EOL);

Extension/src/telemetry.ts

@@ -30,23 +30,25 @@ export function deactivate(): void {
 }
 
 export function logDebuggerEvent(eventName: string, properties?: { [key: string]: string }): void {
-    const eventNamePrefix: string = "cppdbg/VS/Diagnostics/Debugger/";
     if (telemetryReporter) {
+        const eventNamePrefix: string = "cppdbg/VS/Diagnostics/Debugger/";
         telemetryReporter.sendTelemetryEvent(eventNamePrefix + eventName, properties);
     }
 }
 
 export function logLanguageServerEvent(eventName: string, properties?: { [key: string]: string }, metrics?: { [key: string]: number }): void {
-    const eventNamePrefix: string = "C_Cpp/LanguageServer/";
     if (telemetryReporter) {
+        const eventNamePrefix: string = "C_Cpp/LanguageServer/";
         telemetryReporter.sendTelemetryEvent(eventNamePrefix + eventName, properties, metrics);
     }
 }
 
 function createReporter(): TelemetryReporter {
-    let packageInfo: IPackageInfo = getPackageInfo();
-    if (packageInfo && packageInfo.aiKey) {
-        return new TelemetryReporter(packageInfo.name, packageInfo.version, packageInfo.aiKey);
+    if (util.extensionContext) {
+        let packageInfo: IPackageInfo = getPackageInfo();
+        if (packageInfo && packageInfo.aiKey) {
+            return new TelemetryReporter(packageInfo.name, packageInfo.version, packageInfo.aiKey);
+        }
     }
     return null;
 }

Extension/test.tsconfig.json

@@ -0,0 +1,17 @@
+{
+	"compilerOptions": {
+		"module": "commonjs",
+		"target": "es6",
+		"outDir": "out",
+		"lib": [
+			"es6", "dom"
+		],
+		"sourceMap": true,
+		"rootDir": ".",
+		"removeComments": true,
+		"noImplicitUseStrict": true
+	},
+	"include": [
+		"test/**/*.ts"
+	]
+}

Extension/test/integrationTests/MockDebugger/debugAdapterDescriptorFactory.ts

@@ -0,0 +1,47 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All Rights Reserved.
+ * See 'LICENSE' in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import * as vscode from "vscode";
+import * as path from 'path';
+
+// import * as util from '../src/common' <- DO NOT USE. Also do not use anything with relative paths, it will break during replacing in test/integrationTests/debug/integration.test.ts
+
+abstract class AbstractDebugAdapterDescriptorFactory implements vscode.DebugAdapterDescriptorFactory {
+    protected readonly context: vscode.ExtensionContext;
+
+    constructor(context: vscode.ExtensionContext) {
+        this.context = context;
+    }
+
+    abstract createDebugAdapterDescriptor(session: vscode.DebugSession, executable: vscode.DebugAdapterExecutable | undefined): vscode.ProviderResult<vscode.DebugAdapterDescriptor>;
+}
+
+export class CppdbgDebugAdapterDescriptorFactory extends AbstractDebugAdapterDescriptorFactory {
+    public static DEBUG_TYPE : string = "cppdbg";
+
+    constructor(context: vscode.ExtensionContext) {
+        super(context);
+    }
+
+    createDebugAdapterDescriptor(session: vscode.DebugSession, executable: vscode.DebugAdapterExecutable | undefined): vscode.ProviderResult<vscode.DebugAdapterDescriptor> {
+        console.warn("This should only appear in a test scenario.");
+
+        return new vscode.DebugAdapterExecutable('node', [path.join(this.context.extensionPath, './out/test/integrationTests/MockDebugger/mockDebug.js')]);
+    }
+}
+
+export class CppvsdbgDebugAdapterDescriptorFactory extends AbstractDebugAdapterDescriptorFactory {
+    public static DEBUG_TYPE : string = "cppvsdbg";
+
+    constructor(context: vscode.ExtensionContext) {
+        super(context);
+    }
+
+    createDebugAdapterDescriptor(session: vscode.DebugSession, executable: vscode.DebugAdapterExecutable | undefined): vscode.ProviderResult<vscode.DebugAdapterDescriptor> {
+        console.warn("This should only appear in a test scenario.");
+
+        return new vscode.DebugAdapterExecutable('node', [path.join(this.context.extensionPath, './out/test/integrationTests/MockDebugger/mockDebug.js')]);
+    }
+}

Extension/test/integrationTests/MockDebugger/mockDebug.ts

@@ -0,0 +1,8 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All Rights Reserved.
+ * See 'LICENSE' in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import { MockDebugSession } from './mockDebugSession';
+
+MockDebugSession.run(MockDebugSession);

Extension/test/integrationTests/MockDebugger/mockDebugSession.ts

@@ -0,0 +1,67 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All Rights Reserved.
+ * See 'LICENSE' in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import { Logger, logger, LoggingDebugSession, InitializedEvent, TerminatedEvent } from 'vscode-debugadapter';
+import { DebugProtocol } from 'vscode-debugprotocol';
+import { Subject } from 'await-notify';
+
+interface LaunchRequestArguments extends DebugProtocol.LaunchRequestArguments {
+    /** An absolute path to the "program" to debug. */    
+    program: string;
+
+    /** enable logging the Debug Adapter Protocol */    
+    logPath?: string;
+}
+
+export class MockDebugSession extends LoggingDebugSession
+{
+	private _configurationDone = new Subject();
+
+    public constructor() {
+        super("mock-debug.txt");
+    }
+
+    protected initializeRequest(response: DebugProtocol.InitializeResponse, args: DebugProtocol.InitializeRequestArguments): void {
+		// build and return the capabilities of this debug adapter:
+		response.body = response.body || {};
+		
+		// the adapter implements the configurationDoneRequest.
+
+		response.body.supportsConfigurationDoneRequest = true;
+        
+		this.sendResponse(response);
+		// since this debug adapter can accept configuration requests like 'setBreakpoint' at any time,
+		// we request them early by sending an 'initializeRequest' to the frontend.
+		// The frontend will end the configuration sequence by calling 'configurationDone' request.
+		this.sendEvent(new InitializedEvent());
+
+	}
+
+	protected configurationDoneRequest(response: DebugProtocol.ConfigurationDoneResponse, args: DebugProtocol.ConfigurationDoneArguments): void {
+
+		super.configurationDoneRequest(response, args);
+		// notify the launchRequest that configuration has finished
+		this._configurationDone.notify();
+
+	}
+
+	protected async launchRequest(response: DebugProtocol.LaunchResponse, args: LaunchRequestArguments) {
+		// make sure to 'Stop' the buffered logging if 'trace' is not set
+		logger.setup(Logger.LogLevel.Verbose, args.logPath);
+		
+		// wait until configuration has finished (and configurationDoneRequest has been called)
+		await this._configurationDone.wait(1000);
+
+		this.sendResponse(response);
+
+		// Terminate after launch. 
+		this.sendEvent(new TerminatedEvent());
+	}
+
+	protected async disconnectRequest(response: DebugProtocol.DisconnectResponse, args: DebugProtocol.DisconnectArguments)
+	{
+		this.sendResponse(response);
+	}
+}

Extension/test/integrationTests/debug/index.ts

@@ -7,14 +7,15 @@
 import * as fs from "fs";
 import * as path from 'path';
 
-import { subscribeToAllLoggers } from "../../src/logger";
+import { subscribeToAllLoggers } from "../../../src/logger";
 
 // 
 // PLEASE DO NOT MODIFY / DELETE UNLESS YOU KNOW WHAT YOU ARE DOING  
 //
 // This file is providing the test runner to use when running extension tests.
 // By default the test runner in use is Mocha based.
-// 
+// git status
+
 // You can provide your own test runner if you want to override it by exporting
 // a function run(testRoot: string, clb: (error:Error) => void) that the extension
 // host can call to run the tests. The test runner is expected to use console.log
@@ -26,8 +27,9 @@ var testRunner = require('vscode/lib/testrunner');
 // You can directly control Mocha options by uncommenting the following lines
 // See https://github.com/mochajs/mocha/wiki/Using-mocha-programmatically#set-options for more info
 testRunner.configure({
-	ui: 'tdd', 		// the TDD UI is being used in extension.test.ts (suite, test, etc.)
-	useColors: true, // colored output from test results
+    ui: 'tdd', 		// the TDD UI is being used in *.test.ts (suite, test, etc.)
+    useColors: true, // colored output from test results
+    fullTrace: true,
     timeout: 60000
 });
 

Extension/test/integrationTests/debug/integration.test.ts

@@ -6,25 +6,30 @@
 import * as vscode from 'vscode';
 import * as assert from 'assert';
  
-suite(`Debug Integration Test: `, function() {
-    suiteSetup(async function() { 
-        let extension = vscode.extensions.getExtension("ms-vscode.cpptools"); 
-        if (!extension.isActive) { 
+suite(`Debug Integration Test: `, function(): void {
+    let origFactoryFile: string;
+    let tempFactoryFile: string;
+    let hijackedFactoryFile: string;
+
+    suiteSetup(async function(): Promise<void> {
+        let extension: vscode.Extension<any> = vscode.extensions.getExtension("ms-vscode.cpptools"); 
+        if (!extension.isActive) {
             await extension.activate(); 
         }
-    }); 
+    });
  
     test("Starting (gdb) Launch from the workspace root should create an Active Debug Session", async () => { 
+        // If it is failing on startDebugging. Investigate the SimpleCppProject's tasks.json or launch.json.
         await vscode.debug.startDebugging(vscode.workspace.workspaceFolders[0], "(gdb) Launch");
 
-        let debugSessionTerminated = new Promise(resolve => {
+        let debugSessionTerminated: Promise<void> = new Promise(resolve => {
             vscode.debug.onDidTerminateDebugSession((e) => resolve());
         });
 
         try {
             assert.equal(vscode.debug.activeDebugSession.type, "cppdbg");
         } catch (e) {
-            assert.fail("Debugger failed to launch. Did the extension activate correctly?")
+            assert.fail("Debugger failed to launch. Did the extension activate correctly?");
         }
 
         await debugSessionTerminated;

Extension/test/integrationTests/languageServer/index.ts

@@ -0,0 +1,42 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All Rights Reserved.
+ * See 'LICENSE' in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import * as fs from "fs";
+import * as path from 'path';
+
+import { subscribeToAllLoggers } from "../../../src/logger";
+
+// 
+// PLEASE DO NOT MODIFY / DELETE UNLESS YOU KNOW WHAT YOU ARE DOING  
+//
+// This file is providing the test runner to use when running extension tests.
+// By default the test runner in use is Mocha based.
+// 
+// You can provide your own test runner if you want to override it by exporting
+// a function run(testRoot: string, clb: (error:Error) => void) that the extension
+// host can call to run the tests. The test runner is expected to use console.log
+// to report the results back to the caller. When the tests are finished, return
+// a possible error to the callback or null if none.
+
+import testRunner = require('vscode/lib/testrunner');
+
+// You can directly control Mocha options by uncommenting the following lines
+// See https://github.com/mochajs/mocha/wiki/Using-mocha-programmatically#set-options for more info
+testRunner.configure({
+    ui: 'tdd', 		// the TDD UI is being used in *.test.ts (suite, test, etc.)
+    useColors: true, // colored output from test results
+    fullStackTrace: true,
+    timeout: 60000
+});
+
+const logFolder: string = path.join( __dirname, ".logs");
+
+if (!fs.existsSync(logFolder)) {
+    fs.mkdirSync(logFolder);
+}
+const logFilePath: string = path.join(logFolder, "integrationTests.log");
+subscribeToAllLoggers(message => fs.appendFileSync(logFilePath, message));
+
+module.exports = testRunner;

Extension/test/integrationTests/languageServer/languageServer.integration.test.ts

@@ -5,17 +5,21 @@
 
 import * as vscode from 'vscode';
 import * as assert from 'assert';
-import { getLanguageConfigFromPatterns } from '../../src/LanguageServer/languageConfig';
-import * as util from '../../src/common';
+import { getLanguageConfigFromPatterns } from '../../../src/LanguageServer/languageConfig';
+import * as util from '../../../src/common';
 import * as api from 'vscode-cpptools';
 import * as apit from 'vscode-cpptools/out/testApi';
-import * as config from '../../src/LanguageServer/configurations';
-import { CppSettings } from '../../src/LanguageServer/settings';
-import { getActiveClient } from '../../src/LanguageServer/extension';
+import * as config from '../../../src/LanguageServer/configurations';
+import { getActiveClient } from '../../../src/LanguageServer/extension';
+import { initializeTemporaryCommandRegistrar } from '../../../src/commands';
+
+const defaultTimeout: number = 60000;
 
 suite("multiline comment setting tests", function(): void {
     suiteSetup(async function(): Promise<void> { 
-        let extension: vscode.Extension<any> = vscode.extensions.getExtension("ms-vscode.cpptools"); 
+        let extension: vscode.Extension<any> = vscode.extensions.getExtension("ms-vscode.cpptools");
+        util.setExtensionPath(extension.extensionPath);
+        initializeTemporaryCommandRegistrar();
         if (!extension.isActive) { 
             await extension.activate(); 
         }
@@ -187,7 +191,7 @@ suite("extensibility tests v2", function(): void {
                     resolve();
                 }
             }));
-            setTimeout(() => { reject(new Error("timeout")); }, 2500);
+            setTimeout(() => { reject(new Error("timeout")); }, defaultTimeout);
         });
         disposables.push(testHook);
 
@@ -262,7 +266,7 @@ suite("extensibility tests v1", function(): void {
                     resolve();
                 }
             }));
-            setTimeout(() => { reject(new Error("timeout")); }, 2500);
+            setTimeout(() => { reject(new Error("timeout")); }, defaultTimeout);
         });
         disposables.push(testHook);
 
@@ -334,7 +338,7 @@ suite("extensibility tests v0", function(): void {
                     resolve();
                 }
             }));
-            setTimeout(() => { reject(new Error("timeout")); }, 2500);
+            setTimeout(() => { reject(new Error("timeout")); }, defaultTimeout);
         });
         disposables.push(testHook);
 

Extension/test/integrationTests/testAssets/SimpleCppProject/.vscode/launch.json

@@ -5,15 +5,12 @@
             "name": "(gdb) Launch",
             "type": "cppdbg",
             "request": "launch",
-            "preLaunchTask": "build",
             "program": "${workspaceFolder}/program",
             "args": [],
             "stopAtEntry": false,
             "cwd": "${workspaceFolder}",
             "environment": [],
             "externalConsole": true,
-            "MIMode": "gdb",
-            "miDebuggerPath": "/usr/bin/gdb",
             "setupCommands": [
                 {
                     "description": "Enable pretty-printing for gdb",
@@ -22,10 +19,17 @@
                 }
             ],
             "windows": {
+                "MIMode": "gdb",
                 "miDebuggerPath": "C:\\MinGW\\bin\\gdb.exe"
             },
             "osx": {
-                "miDebuggerPath": "/usr/bin/lldb"
+                "MIMode": "lldb",
+                "preLaunchTask": "build"
+            },
+            "linux": {
+                "MIMode": "gdb",
+                "miDebuggerPath": "/usr/bin/gdb",
+                "preLaunchTask": "build"
             }
         }
     ]

Extension/test/integrationTests/testAssets/SimpleCppProject/.vscode/tasks.json

@@ -1,16 +1,34 @@
 {
-    "version": "0.1.0",
+    "version": "2.0.0",
 	"tasks": [
         {
-            "taskName": "build",
-			"command": "g++",
-			"isShellCommand": true,
-			"args": ["main.cpp", "-g", "-o", "program"],
-			"showOutput": "always",
-			"isBuildCommand": true,
-			"windows": {
-				"command": "C:\\MinGW\\bin\\g++.exe"
-			}
+            "label": "build",
+            "command": "g++",
+            "type": "shell",
+            "args": [
+                "main.cpp",
+                "-g",
+                "-o",
+                "program"
+            ],
+            "group":{
+                "kind": "build",
+                "isDefault": true
+            },
+            "presentation": {
+                "echo": true,
+                "reveal": "always",
+                "focus": false,
+                "panel": "shared",
+                "showReuseMessage": true,
+                "clear": false
+            },
+            "windows": {
+                "command": "C:\\MinGW\\bin\\g++.exe"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ]
         }
     ]
 }

Extension/test/unitTests/ParsedEnvironmentFile.test.ts

@@ -0,0 +1,112 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Environment, ParsedEnvironmentFile } from '../../src/Debugger/ParsedEnvironmentFile'
+import * as assert from 'assert';
+
+// Because the environment variable is set as an array, the index does not matter.
+function AssertEnvironmentEqual(env: Environment[], name: string, value: string) {
+    let found: boolean = false;
+    for (let e of env)
+    {
+        if (e.name == name)
+        {
+            assert(e.value == value, `Checking if ${e.value} == ${value}`);
+            found = true;
+            break;
+        }
+    }
+    assert(found, `${name} was not found in env.`)
+}
+
+suite("ParsedEnvironmentFile", () => {
+    test("Add single variable", () => {
+        const content = `MyName=VALUE`;
+        const fakeConfig : Environment[] = [];
+        const result = ParsedEnvironmentFile.CreateFromContent(content, "TestEnvFileName", fakeConfig["env"]);
+
+        assert(result.Warning == null, `Failed to assert that Warning was empty: ${result.Warning}`);
+        AssertEnvironmentEqual(result.Env, "MyName", "VALUE");
+    });
+
+    test("Handle quoted values", () => {
+        const content = `MyName="VALUE"`;
+        const fakeConfig : Environment[] = [];
+        const result = ParsedEnvironmentFile.CreateFromContent(content, "TestEnvFileName", fakeConfig["env"]);
+
+        assert(result.Warning == null, `Failed to assert that Warning was empty: ${result.Warning}`);
+        AssertEnvironmentEqual(result.Env, "MyName", "VALUE");
+    });
+
+    test("Handle BOM", () => {
+        const content = "\uFEFFMyName=VALUE";
+        const fakeConfig : Environment[] = [];
+        const result = ParsedEnvironmentFile.CreateFromContent(content, "TestEnvFileName", fakeConfig["env"]);
+
+        assert(result.Warning == null, `Failed to assert that Warning was empty: ${result.Warning}`);
+        AssertEnvironmentEqual(result.Env, "MyName", "VALUE");
+    });
+
+    test("Add multiple variables", () => {
+        const content = `
+MyName1=Value1
+MyName2=Value2
+
+`;
+        const fakeConfig : Environment[] = [];
+        const result = ParsedEnvironmentFile.CreateFromContent(content, "TestEnvFileName", fakeConfig["env"]);
+
+        assert(result.Warning == null, `Failed to assert that Warning was empty: ${result.Warning}`);
+        AssertEnvironmentEqual(result.Env, "MyName1", "Value1");
+        AssertEnvironmentEqual(result.Env, "MyName2", "Value2");
+    });
+
+    test("Update variable", () => {
+        const content = `
+MyName1=Value1
+MyName2=Value2
+
+`;
+        const initialEnv : Environment[] = [];
+        initialEnv.push({name : "MyName1", value: "Value7"});
+        initialEnv.push({name : "ThisShouldNotChange", value : "StillHere"});
+        
+        const result = ParsedEnvironmentFile.CreateFromContent(content, "TestEnvFileName", initialEnv);
+
+        assert(result.Warning == null, `Failed to assert that Warning was empty: ${result.Warning}`);
+        AssertEnvironmentEqual(result.Env, "MyName1", "Value1");
+        AssertEnvironmentEqual(result.Env, "ThisShouldNotChange", "StillHere");
+        AssertEnvironmentEqual(result.Env, "MyName2", "Value2");
+    });
+
+    test("Handle comments", () => {
+        const content = `# This is an environment file    
+MyName1=Value1
+# This is a comment in the middle of the file
+MyName2=Value2
+`;
+        const fakeConfig : Environment[] = [];
+        const result = ParsedEnvironmentFile.CreateFromContent(content, "TestEnvFileName", fakeConfig["env"]);
+
+        assert(result.Warning == null, `Failed to assert that Warning was empty: ${result.Warning}`);
+        AssertEnvironmentEqual(result.Env, "MyName1", "Value1");
+        AssertEnvironmentEqual(result.Env, "MyName2", "Value2");
+    });
+    
+    test("Handle invalid lines", () => {
+        const content = `
+This_Line_Is_Wrong
+MyName1=Value1
+MyName2=Value2
+
+`;
+        const fakeConfig : Environment[] = [];
+        const result = ParsedEnvironmentFile.CreateFromContent(content, "TestEnvFileName", fakeConfig["env"]);
+
+        assert(result.Warning.startsWith("Ignoring non-parseable lines in envFile TestEnvFileName"), 'Checking if warning exists');
+        AssertEnvironmentEqual(result.Env, "MyName1", "Value1");
+        AssertEnvironmentEqual(result.Env, "MyName2", "Value2");
+    });
+});

Extension/test/unitTests/common.test.ts

@@ -4,7 +4,7 @@
  * ------------------------------------------------------------------------------------------ */
 
 import * as assert from "assert";
-import {  resolveVariables } from "../../src/common";
+import { resolveVariables, escapeForSquiggles } from "../../src/common";
 
 suite("Common Utility validation", () => {
     suite("resolveVariables", () => {
@@ -198,6 +198,25 @@ suite("Common Utility validation", () => {
                 .shouldLookupSymbol("Root");
         });
 
+        test("escapeForSquiggles:", () => {
+            let testEscapeForSquigglesScenario: any = (input: string, expectedOutput: string) => {
+                let result: string = escapeForSquiggles(input);
+                if (result !== expectedOutput) {
+                    throw new Error(`escapeForSquiggles failure: for \"${input}\", \"${result}\" !== \"${expectedOutput}\"`);
+                }
+            };
+
+            testEscapeForSquigglesScenario("\\", "\\\\"); // single backslash
+            testEscapeForSquigglesScenario("\\\"", "\\\""); // escaped quote
+            testEscapeForSquigglesScenario("\\\t", "\\\\\t"); // escaped non-quote
+            testEscapeForSquigglesScenario("\\\\\"", "\\\\\\\\\""); // escaped backslash, unescaped quote
+            testEscapeForSquigglesScenario("\\\\\t", "\\\\\\\\\t"); // escaped backslash, unescaped non-quote
+            testEscapeForSquigglesScenario("\\t", "\\\\t"); // escaped non-quote
+            testEscapeForSquigglesScenario("\\\\\\t", "\\\\\\\\\\\\t"); // escaped backslash, unescaped non-quote
+            testEscapeForSquigglesScenario("\"\"", "\"\""); // empty quoted string
+            testEscapeForSquigglesScenario("\"\\\\\"", "\"\\\\\\\\\""); // quoted string containing escaped backslash
+        });
+
         interface ResolveTestFlowEnvironment {
             withEnvironment(additionalEnvironment: {[key: string]: string | string[]}): ResolveTestFlowAssert;
             shouldLookupSymbol: (key: string) => void;
@@ -229,6 +248,5 @@ suite("Common Utility validation", () => {
                 }
             };
         }
-
     });
 });

Extension/tools/OptionsSchema.json

@@ -110,8 +110,12 @@
       "type": "object",
       "default": {},
       "properties": {
-        "name": "string",
-        "value": "string"
+        "name": {
+            "type": "string"
+        },
+        "value": {
+            "type": "string"
+        }
       }
     },
     "CppdbgLaunchOptions": {
@@ -259,7 +263,12 @@
         },
         "externalConsole": {
           "type": "boolean",
-          "description": "If true, a console is launched for the debuggee. If false, no console is launched. Note this option is ignored in some cases for technical reasons.",
+          "description": "If true, a console is launched for the debuggee. If false, on Linux and Windows, it will appear in the Integrated Console.",
+          "default": false
+        },
+        "avoidWindowsConsoleRedirection": {
+          "type": "boolean",
+          "description": "If true, disables debuggee console redirection that is required for Integrated Terminal support.",
           "default": false
         },
         "sourceFileMap": {
@@ -336,12 +345,12 @@
           "anyOf": [
             {
               "type": "string",
-              "description": "Optional process id to attach the debugger to. Use \"${command:pickProcesss}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
+              "description": "Optional process id to attach the debugger to. Use \"${command:pickProcess}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
               "default": "${command:pickProcess}"
             },
             {
               "type": "integer",
-              "description": "Optional process id to attach the debugger to. Use \"${command:pickProcesss}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
+              "description": "Optional process id to attach the debugger to. Use \"${command:pickProcess}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
               "default": 0
             }
           ]
@@ -420,6 +429,11 @@
           },
           "default": []
         },
+        "envFile": { 
+          "type": "string", 
+          "description": "Absolute path to a file containing environment variable definitions. These file has key value pairs sepearted by an equals sign per line. E.g. KEY=VALUE", 
+          "default": "${workspaceFolder}/.env"
+        },
         "symbolSearchPath": {
           "type": "string",
           "description": "Semicolon separated list of directories to use to search for symbol (that is, pdb) files. Example: \"c:\\dir1;c:\\dir2\".",
@@ -452,6 +466,11 @@
             "<source-path>": "<target-path>"
           }
         },
+        "enableDebugHeap": {
+          "type": "boolean",
+          "description": "If false, the process will be launched with debug heap disabled. This sets the environment variable '_NO_DEBUG_HEAP' to '1'.",
+          "default": false
+        },
         "logging": {
           "type": "object",
           "description": "Optional flags to determine what types of messages should be logged to the Debug Console.",
@@ -502,12 +521,12 @@
           "anyOf": [
             {
               "type": "string",
-              "description": "Optional process id to attach the debugger to. Use \"${command:pickProcesss}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
+              "description": "Optional process id to attach the debugger to. Use \"${command:pickProcess}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
               "default": "${command:pickProcess}"
             },
             {
               "type": "integer",
-              "description": "Optional process id to attach the debugger to. Use \"${command:pickProcesss}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
+              "description": "Optional process id to attach the debugger to. Use \"${command:pickProcess}\" to get a list of local running processes to attach to. Note that some platforms require administrator privileges in order to attach to a process.",
               "default": 0
             }
           ]

Extension/tools/prepublish.js

@@ -10,9 +10,17 @@
  */
 
 const fs = require("fs");
+const os = require("os");
 const cp = require("child_process");
 const path = require("path");
 
+let compile = function(tsPath) {
+    const folderName = path.dirname(tsPath);
+
+    console.log(">> tsc " + tsPath + " --outDir out/" + folderName);
+    cp.execSync("tsc " + tsPath + " --outDir out/" + folderName, {stdio:[0, 1, 2]});
+};
+
 if (!process.env.CPPTOOLS_DEV && fs.existsSync('./node_modules')) {
     console.warn("WARNING: Skipping npm install since it appears to have been executed already.");
 } else {
@@ -20,13 +28,17 @@ if (!process.env.CPPTOOLS_DEV && fs.existsSync('./node_modules')) {
     cp.execSync("npm install", { stdio: [0, 1, 2] });
 }
 
-// Compile the TypeScript code
-console.log(">> tsc -p ./");
-cp.execSync("tsc -p ./", {stdio:[0, 1, 2]});
+const tscCompileListStr = fs.readFileSync("./tscCompileList.txt").toString();
+
+tscCompileListStr.split(/\r?\n/).forEach(filePath => {
+    if (!filePath.startsWith("#") && /\S/.test(filePath)) {
+        compile(filePath);
+    }
+});
 
 // If the required debugger file doesn't exist, make sure it is copied.
 if (process.env.CPPTOOLS_DEV || !fs.existsSync('./debugAdapters/bin/cppdbg.ad7Engine.json')) {
-    const copyDebuggerDependenciesJSFile = './out/src/Support/copyDebuggerDependencies.js';
+    const copyDebuggerDependenciesJSFile = './out/tools/copyDebuggerDependencies.js';
 
     // Required for nightly builds. Nightly builds do not enable CPPTOOLS_DEV.
     console.log(">> node " + copyDebuggerDependenciesJSFile);

Extension/tscCompileList.txt

@@ -0,0 +1,13 @@
+# This file is consumed in tools\prepublish.js
+# '#' at the start of the line is treated as a comment and is ignored.
+# whitespace empty lines are also ignores.
+#
+# This file is to be used if you do not wish to webpack a .ts file
+# If you do not want it to be webpacked:
+# 1. Please make sure it is not in the src directory
+# 2. Add it to the list below
+# 3. If you created a new folder, please make sure it is added to the .vscodeignore 
+
+tools/GenerateOptionsSchema.ts
+tools/copyDebuggerDependencies.ts
+ui/settings.ts

Extension/tsconfig.json

@@ -4,15 +4,16 @@
 		"target": "es6",
 		"outDir": "out",
 		"lib": [
-			"es6"
+			"es6", "dom"
 		],
 		"sourceMap": true,
 		"rootDir": ".",
 		"removeComments": true,
 		"noImplicitUseStrict": true
 	},
-	"exclude": [
-		"node_modules",
-		"server"
+	"include": [
+		"src/**/*.ts",
+		"./node_modules/vscode/vscode.d.ts",
+		"./node_modules/vscode/lib/*",
 	]
 }

Extension/ui/settings.html

@@ -0,0 +1,441 @@
+
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="Content-Security-Policy" content="style-src 'unsafe-inline'; img-src vscode-resource:; script-src 'nonce-{{nonce}}';">
+
+    <style type="text/css">
+      @media (max-width: 1140px) {
+          #sidebar {
+              display: none;
+          }
+          #main {
+            max-width: 800px;
+            padding: 0px 20px;
+            margin: auto;
+          }
+      }
+
+      .page-margins {
+          vertical-align: top;
+          padding-top: 40px;
+          padding-bottom: 10px
+      }
+
+      .sidebar {
+          width: 290px;
+          position: fixed;
+          z-index: 1;
+          left: 45px;
+          overflow-x: hidden;
+      }
+
+      .error {
+        color: var(--vscode-inputValidation-errorForeground);
+        background: var(--vscode-inputValidation-errorBackground);
+        border: solid 1px var(--vscode-inputValidation-errorBorder);
+        white-space: pre-wrap;
+        visibility: hidden;
+        display: block;
+        padding: 1px 4px 4px 4px;
+      }
+
+      .main {
+          max-width: 800px;
+          margin-left: 320px;
+          padding: 0px 30px;
+      }
+
+      .main-title {
+          font-weight: 500;
+          font-size: 22px;
+          padding-bottom: 6px;
+          color: var(--vscode-foreground);
+      }
+
+      .section {
+          padding-bottom: 35px;
+      }
+
+      .section-title {
+          font-weight: 500;
+          font-size: 14px;
+          padding-bottom: 4px;
+          color: var(--vscode-foreground);
+      }
+
+      .section-text {
+          font-size: 14px;
+          padding-bottom: 8px;
+          color: var(--vscode-foreground);
+      }
+
+      .section-note {
+          font-size: 14px;
+          font-style: italic;
+          padding-bottom: 2px;
+          color: var(--vscode-foreground);
+      }
+
+      .codeblock {
+          vertical-align: middle;
+          padding: 2px 8px;
+          margin-top: 8px;
+          display: inline-block;
+          font-family: Menlo, Monaco, Consolas, "Droid Sans Mono", "Courier New", monospace, "Droid Sans Fallback";
+          border-radius: 5px;
+      }
+
+      body {
+          line-height: 19px
+      }
+
+      a {
+          text-decoration: none
+      }
+
+      a:focus,
+      input:focus,
+      select:focus,
+      textarea:focus {
+          outline: 1px solid -webkit-focus-ring-color;
+          outline-offset: -1px
+      }
+
+      hr {
+          border: 0;
+          height: 1px;
+          border-bottom: 1px solid;
+      }
+
+      h1 {
+          padding-bottom: .3em;
+      }
+
+      h1,
+      h2,
+      h3 {
+          font-weight: 400
+      }
+
+      a:hover {
+          text-decoration: underline
+      }
+
+      input {
+          height: 17px;
+          padding: 6px;
+          border: solid 1px;
+          font-size: 13px;
+          font-family: Menlo, Monaco, Consolas, "Droid Sans Mono", "Courier New", monospace, "Droid Sans Fallback";
+          color: var(--vscode-settings-textInputForeground);
+          background: var(--vscode-settings-textInputBackground);
+          border: 1px solid var(--vscode-settings-textInputBorder);
+      }
+
+      textarea {
+          white-space: nowrap;
+          padding: 4px, 4px;
+          font-size: 13px;
+          font-family: Menlo, Monaco, Consolas, "Droid Sans Mono", "Courier New", monospace, "Droid Sans Fallback";
+          color: var(--vscode-settings-textInputForeground);
+          background: var(--vscode-settings-textInputBackground);
+          border: 1px solid var(--vscode-settings-textInputBorder);
+      }
+
+      select {
+          width: 300px;
+          height: 27px;
+          font-size: 13px;
+          font-family:sans-serif;
+          color: var(--vscode-settings-dropdownForeground);
+          background: var(--vscode-settings-dropdownBackground);
+          border: 1px solid var(--vscode-settings-dropdownBorder);
+      }
+
+      blockquote {
+          margin: 0 7px 0 5px;
+          padding: 0 16px 0 10px;
+          border-left: 5px solid;
+      }
+
+      code {
+          font-family: Menlo, Monaco, Consolas, "Droid Sans Mono", "Courier New", monospace, "Droid Sans Fallback";
+          line-height: 19px
+      }
+
+      .mac code {
+          line-height: 18px
+      }
+
+      code > div {
+          padding: 16px;
+          border-radius: 3px;
+          overflow: auto
+      }
+
+      .monaco-tokenized-source {
+          white-space: pre
+      }
+
+      /** Theming */
+
+      .vscode-light {
+          color: #1e1e1e
+      }
+
+      .vscode-dark {
+          color: #ddd
+      }
+
+      .vscode-high-contrast {
+          color: #fff
+      }
+
+      .vscode-light code {
+          color: #a31515
+      }
+
+      .vscode-dark code {
+          color: #d7ba7d
+      }
+
+      .vscode-light code > div {
+          background-color: rgba(220, 220, 220, .4)
+      }
+
+      .vscode-dark code > div {
+          background-color: rgba(10, 10, 10, .4)
+      }
+
+      .vscode-light .input-disabled {
+          background-color:rgba(255, 255, 255, 0.4);
+          color: rgb(138, 138, 138);
+          border: solid 1px rgb(201, 198, 198);
+      }
+
+      .vscode-dark .input-disabled {
+          background-color: rgba(255, 255, 255, 0.1);
+          color: rgb(167, 167, 167);
+      }
+
+      .vscode-high-contrast .input-disabled {
+          background-color: transparent;
+          color: #fff;
+          border: solid 1px rgb(255, 255, 255);
+      }
+
+      .vscode-high-contrast code > div {
+          background-color: #000
+      }
+
+      .vscode-high-contrast h1 {
+          border-color: #000
+      }
+
+      .vscode-light table > thead > tr > th {
+          border-color: rgba(0, 0, 0, .69)
+      }
+
+      .vscode-dark table > thead > tr > th {
+          border-color: rgba(255, 255, 255, .69)
+      }
+
+      .vscode-light h1,
+      .vscode-light hr,
+      .vscode-light table > tbody > tr + tr > td {
+          border-color: rgba(0, 0, 0, .18)
+      }
+
+      .vscode-dark h1,
+      .vscode-dark hr,
+      .vscode-dark table > tbody > tr + tr > td {
+          border-color: rgba(255, 255, 255, 0.18)
+      }
+
+      .vscode-light blockquote,
+      .vscode-dark blockquote {
+          background: rgba(127, 127, 127, .1);
+          border-color: rgba(0, 122, 204, .5)
+      }
+
+      .vscode-high-contrast blockquote {
+          background: transparent;
+          border-color: #fff
+      }
+
+      .vscode-light div.codeblock {
+          background-color: rgba(0, 0, 0, 0.048)
+      }
+
+      .vscode-dark div.codeblock {
+          background-color: rgba(255, 255, 255, 0.1)
+      }
+
+      .vscode-high-contrast div.codeblock {
+          background-color: rgba(255, 255, 255, 0.15)
+      }
+
+      .footer {
+          padding: 25px;
+          text-align: center
+      }
+
+      .vscode-light a {
+          color: #4080D0
+      }
+
+      .vscode-dark a {
+          color: #a2c1e8
+      }
+
+  </style>
+
+  </head>
+
+  <body class="page-margins">
+
+  <!-- sidebar -->
+  <div id="sidebar" class="sidebar">
+
+    <div style="height: 90px; display: block">
+        <table>
+            <td>
+              <img src="{{root}}/LanguageCCPP_color_128x.png" height="76" width="76" alt="Microsoft C/C++ Extension" title="Microsoft C/C++ Extension" style="padding-right: 10px">
+            </td>
+            <td>
+                <div style="font-size: 20px; font-weight: 400; line-height: 24px">Microsoft<br>C/C++ Extension</div>
+            </td>
+          </table>
+    </div>
+
+    <hr>
+    <div style="height: 30px; display: block"></div>
+
+    <div style="padding-right: 10px; color: var(--vscode-foreground);">
+        Open this editor by using the command:<br>
+        <code>C/C++: Edit configurations (UI)</code>
+
+        <div style="height: 30px; display: block"></div>
+
+        Switch to the <a href="command:C_Cpp.ConfigurationEditJSON" title="Edit configurations in JSON file">c_cpp_properties.json</a> file by clicking on the file link or using the command:<br> 
+        <code>C/C++: Edit configurations (JSON)</code>
+    </div>
+
+  </div> <!-- sidebar end -->
+
+  <!-- main -->
+  <div id="main" class="main">
+
+    <!-- title -->
+    <div style=" height: 90px; display: inline-block;">
+      <div class="main-title">IntelliSense Configurations</div>
+      <div style="color: var(--vscode-foreground);">
+        Use this editor to edit basic IntelliSense settings defined in the underlying <a href="command:C_Cpp.ConfigurationEditJSON" title="Edit configurations in JSON file">c_cpp_properties.json</a> file.
+        Changes made in this editor only apply to the active configuration. To modify other configurations <a href="command:C_Cpp.ConfigurationSelect" title="Change the active configuration">change the active configuration</a>. 
+        To edit multiple configurations at once, or additional settings not shown here, go to <a href="command:C_Cpp.ConfigurationEditJSON" title="Edit configurations in JSON file">c_cpp_properties.json</a>.
+      </div>
+    </div>
+
+    <hr>
+    <div style="height: 30px; display: block"></div>
+
+    <!-- sections -->
+    <div class="section">
+      <div class="section-title">Configuration name</div>
+      <div class="section-text">
+        A friendly name that identifies a configuration. <code>Mac</code>, <code>Linux</code>, and <code>Win32</code> are special identifiers for configurations that will be auto-selected on those platforms, but the name of the identifier can be anything.
+        To edit the name of the current active configuration, go to the <a href="command:C_Cpp.ConfigurationEditJSON" title="Edit configurations in JSON file">c_cpp_properties.json</a> file and edit the <code>name</code> property.
+      </div>
+      <div><input class="input-disabled" type="text" id=activeConfig style="width: 290px" disabled>
+      <a style="padding-left: 6px;" href="command:C_Cpp.ConfigurationSelect" title="Change the active configuration">Change the active configuration</a>
+    </div> 
+    </div>
+
+    <div class="section">
+        <div class="section-title">Compiler path</div>
+        <div class="section-text">
+            The full path of the compiler being used to build, e.g. <code>/usr/bin/gcc</code>, to enable more accurate IntelliSense.
+            Args can be added to modify the includes/defines used, e.g. <code>-nostdinc++</code>, <code>-m32</code>, etc., but paths with spaces must be surrounded by double quotes <code>"</code> if args are used.
+        </div>
+        <div>
+            <input id="compilerPath" style="width: 798px"></input>
+            <div id="compilerPathInvalid" class="error" style="width: 800px"></div>
+        </div>
+    </div>
+
+    <div class="section">
+        <div class="section-title">IntelliSense mode</div>
+        <div class="section-text">
+            The IntelliSense mode used by the IntelliSense engine. The <code>${default}</code> mode will choose the default for that platform. 
+            Windows defaults to <code>msvc-x64</code>, Linux defaults to <code>gcc-x64</code>, and Mac defaults to <code>clang-x64</code>. 
+            Select a specific IntelliSense mode to override the <code>${default}</code> mode.
+        </div>
+        <div>
+          <select id="intelliSenseMode">
+            <option value="${default}">${default}</option>
+            <option value="msvc-x64">msvc-x64</option>
+            <option value="gcc-x64">gcc-x64</option>
+            <option value="clang-x64">clang-x64</option>
+          </select>
+        </div>
+        <div id="intelliSenseModeInvalid" class="error" style="width: 290px"></div>
+    </div>
+
+    <div class="section">
+        <div class="section-title">Include path</div>
+        <div class="section-text">
+            A list of paths for the IntelliSense engine to use while searching for included headers. If a path ends with <code>/**</code> the IntelliSense engine will do a recursive search for headers starting from that directory.
+        </div>
+        <div>
+          <div class="section-note">One include path per line.</div>
+          <textarea id="includePath" rows="4" cols="93" style="width: 800px"></textarea>
+          <div id="includePathInvalid" class="error" style="margin-top: -4px; width: 794px"></div>
+        </div>
+    </div>
+
+    <div class="section">
+        <div class="section-title">Defines</div>
+        <div class="section-text">
+            A list of preprocessor definitions for the IntelliSense engine to use while parsing files. Optionally, use <code>=</code> to set a value, e.g. <code>VERSION=1</code>.
+        </div>
+        <div>
+            <div class="section-note">One definition per line.</div>
+            <textarea id="defines" rows="4" cols="39"></textarea>
+        </div>
+    </div>
+
+    <div class="section">
+        <div class="section-title">C Standard</div>
+        <div class="section-text">The version of the C language standard to use for IntelliSense.</div>
+        <div>
+            <select id="cStandard">
+                <option value="c11">c11</option>
+                <option value="c99">c99</option>
+                <option value="c89">c89</option>
+            </select>
+        </div>
+    </div>
+
+    <div class="section">
+        <div class="section-title">C++ Standard</div>
+        <div class="section-text">The version of the C++ language standard to use for IntelliSense.</div>
+        <div>
+            <select id="cppStandard">
+                <option value="c++17">c++17</option>
+                <option value="c++14">c++14</option>
+                <option value="c++11">c++11</option>
+                <option value="c++03">c++03</option>
+                <option value="c++98">c++98</option>
+            </select>
+        </div> <!-- sections end -->
+
+    </div>
+
+  </div> <!-- main end -->
+
+  <script nonce="{{nonce}}" src="{{root}}/out/ui/settings.js"></script>
+
+</body>
+</html>

Extension/ui/settings.ts

@@ -0,0 +1,120 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All Rights Reserved.
+ * See 'LICENSE' in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+
+const elementId: { [key: string]: string } = {
+    activeConfig: "activeConfig",
+    compilerPath: "compilerPath",
+    intelliSenseMode: "intelliSenseMode", 
+    includePath: "includePath",
+    defines: "defines",
+    cStandard: "cStandard",
+    cppStandard: "cppStandard",
+    compilerPathInvalid: "compilerPathInvalid",
+    intelliSenseModeInvalid: "intelliSenseModeInvalid",
+    includePathInvalid: "includePathInvalid"
+};
+
+interface VsCodeApi {
+    postMessage(msg: {}): void;
+    setState(state: {}): void;
+    getState(): {};
+}
+
+declare function acquireVsCodeApi(): VsCodeApi;
+
+class SettingsApp {
+    private readonly vsCodeApi: VsCodeApi;
+    private updating: boolean = false;
+
+    constructor() {
+        this.vsCodeApi = acquireVsCodeApi();
+
+        window.addEventListener('message', this.onMessageReceived.bind(this));
+
+        document.getElementById(elementId.activeConfig).addEventListener("change", this.onChanged.bind(this, elementId.activeConfig));
+        
+        document.getElementById(elementId.compilerPath).addEventListener("change", this.onChanged.bind(this, elementId.compilerPath));
+        document.getElementById(elementId.intelliSenseMode).addEventListener("change", this.onChanged.bind(this, elementId.intelliSenseMode));
+
+        document.getElementById(elementId.includePath).addEventListener("change", this.onChanged.bind(this, elementId.includePath));
+        document.getElementById(elementId.defines).addEventListener("change", this.onChanged.bind(this, elementId.defines));
+
+        document.getElementById(elementId.cStandard).addEventListener("change", this.onChanged.bind(this, elementId.cStandard));
+        document.getElementById(elementId.cppStandard).addEventListener("change", this.onChanged.bind(this, elementId.cppStandard));
+    }
+
+    private onChanged(id: string): void {
+        if (this.updating) {
+            return; 
+        }
+
+        const x: HTMLInputElement = <HTMLInputElement>document.getElementById(id);
+        this.vsCodeApi.postMessage({
+            command: "change",
+            key: id,
+            value: x.value
+        });
+    }
+
+    private onMessageReceived(e: MessageEvent): void {
+        const message: any = e.data; // The json data that the extension sent
+        switch (message.command) {
+            case 'updateConfig':
+                this.updateConfig(message.config);
+                break;
+            case 'updateErrors':
+                 this.updateErrors(message.errors);
+                 break;
+        }
+    }
+
+    private updateConfig(config: any): void {
+        this.updating = true;
+        try {
+            (<HTMLInputElement>document.getElementById(elementId.activeConfig)).value = config.name;
+
+            (<HTMLInputElement>document.getElementById(elementId.compilerPath)).value = config.compilerPath ? config.compilerPath : "";
+            (<HTMLInputElement>document.getElementById(elementId.intelliSenseMode)).value = config.intelliSenseMode ? config.intelliSenseMode : "${default}";
+
+            (<HTMLInputElement>document.getElementById(elementId.includePath)).value = 
+                (config.includePath && config.includePath.length > 0) ? config.includePath.join("\n") : "";
+
+            (<HTMLInputElement>document.getElementById(elementId.defines)).value = 
+                (config.defines && config.defines.length > 0 ) ? config.defines.join("\n") : "";
+
+            (<HTMLInputElement>document.getElementById(elementId.cStandard)).value = config.cStandard;
+            (<HTMLInputElement>document.getElementById(elementId.cppStandard)).value = config.cppStandard;
+        } finally {
+            this.updating = false;
+        }
+    }
+
+    private updateErrors(errors: any): void {
+        this.updating = true;
+        try {
+            this.showErrorWithInfo(elementId.intelliSenseModeInvalid, 
+                    errors.intelliSenseMode ? true : false, 
+                    errors.intelliSenseMode);
+
+            this.showErrorWithInfo(elementId.compilerPathInvalid, 
+                    errors.compilerPath ? true : false, 
+                    errors.compilerPath);
+
+            this.showErrorWithInfo(elementId.includePathInvalid, 
+                    errors.includePath ? true : false, 
+                    errors.includePath);
+        } finally {
+            this.updating = false;
+        }
+    }
+
+    private showErrorWithInfo(elementID: string, show: boolean, errorInfo: string): void {
+         document.getElementById(elementID).style.visibility = show ? "visible" : "hidden";
+         document.getElementById(elementID).innerHTML = errorInfo ? errorInfo : "";
+    }
+}
+
+let app: SettingsApp = new SettingsApp();

Extension/webpack.config.js

@@ -0,0 +1,41 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+//@ts-check
+
+'use strict';
+
+const path = require('path');
+
+/**@type {import('webpack').Configuration}*/
+const config = {
+    target: 'node', // vscode extensions run in a Node.js-context 📖 -> https://webpack.js.org/configuration/node/
+
+    entry: './src/main.ts', // the entry point of this extension, 📖 -> https://webpack.js.org/configuration/entry-context/
+    output: { // the bundle is stored in the 'dist' folder (check package.json), 📖 -> https://webpack.js.org/configuration/output/
+        path: path.resolve(__dirname, 'dist'),
+        filename: 'main.js',
+        libraryTarget: "commonjs2",
+        devtoolModuleFilenameTemplate: "../[resource-path]",
+    },
+    devtool: 'source-map',
+    externals: {
+        vscode: "commonjs vscode" // the vscode-module is created on-the-fly and must be excluded. Add other modules that cannot be webpack'ed, 📖 -> https://webpack.js.org/configuration/externals/
+    },
+    resolve: { // support reading TypeScript and JavaScript files, 📖 -> https://github.com/TypeStrong/ts-loader
+        extensions: ['.ts', '.js']
+    },
+    module: {
+        rules: [{
+            test: /\.ts$/,
+            exclude: /node_modules/,
+            use: [{
+                loader: 'ts-loader'
+            }]
+        }]
+    },
+}
+
+module.exports = config;

azure-pipelines.yml

@@ -0,0 +1,17 @@
+name: $(Date:yyyyMMdd).$(Rev:r)
+pr: 
+- 'master'
+jobs:
+- template: Extension/jobs/build.yml
+  parameters:
+    name: macOS
+    pool:
+      vmImage: 'macOS-10.13'
+
+- template: Extension/jobs/build.yml
+  parameters:
+    name: Linux
+    pool:
+      vmImage: 'ubuntu-16.04'
+
+- template: Extension/jobs/build.windows.yml

launch.md

@@ -26,6 +26,9 @@ Set or change the following options to control VS Code's behavior during debuggi
   Linux: When set to true, it will notify VS Code to spawn an external console. When set to false, it will use VS Code's integratedTerminal.
   macOS: When set to true, it will spawn an external console through `lldb-mi`. When set to false, the output can be seen in VS Code's debugConsole. Due to limitations within `lldb-mi`, integratedTerminal support is not available.
 
+* #### `avoidWindowsConsoleRedirection`
+  In order to support VSCode's Integrated terminal with gdb on Windows, the extension adds console redirection commands to the debuggee's arguments to have console input and output show up in the integrated terminal. Setting this option to `true` will disable it.
+
 * #### `logging`
   Optional flags to determine what types of messages should be logged to the Debug Console.
   * ##### `exceptions`
@@ -75,7 +78,7 @@ The following options enable you to modify the state of the target application w
   JSON array of command line arguments to pass to the program when it is launched. Example `["arg1", "arg2"]`. If you are escaping characters you will need to double escape them. For example `["{\\\"arg\\\": true}]` will send `{"arg1": true}` to your application.
 
 * #### `cwd`
-  Sets the the working directory of the application launched by the debugger.
+  Sets the working directory of the application launched by the debugger.
 
 * #### `environment`
   Environment variables to add to the environment for the program. Example: `[ { "name": "squid", "value": "clam" } ]`.
@@ -166,7 +169,7 @@ _Note: core dump debugging is not supported with MinGw._
   Full path to debug server to launch.
 
 * #### `debugServerArgs`
-  Arguments for the the debugger server.
+  Arguments for the debugger server.
 
 * #### `serverStarted`
   Server-started pattern to look for in the debug server output.
@@ -191,3 +194,23 @@ _Note: core dump debugging is not supported with MinGw._
 
 * #### `sourceFileMap`
   This allows mapping of the compile time paths for source to local source locations. It is an object of key/value pairs and will resolve the first string-matched path. (example: `"sourceFileMap": { "/mnt/c": "c:\\" }` will map any path returned by the debugger that begins with `/mnt/c` and convert it to `c:\\`. You can have multiple mappings in the object but they will be handled in the order provided.)
+
+## Environment variable definitions file
+
+An environment variable definitions file is a simple text file containing key-value pairs in the form of `environment_variable=value`, with `#` used for comments. Multiline values are not supported.
+
+The `cppvsdbg` debugger configuration also contains an `envFile` property that allows you to easily set variables for debugging purposes.
+
+For example:
+
+**project.env file**
+
+```bash
+# project.env
+
+# Example environment with key as 'MYENVRIONMENTPATH' and value as C:\\Users\\USERNAME\\Project
+MYENVRIONMENTPATH=C:\\Users\\USERNAME\\Project
+
+# Variables with spaces
+SPACED_OUT_PATH="C:\\This Has Spaces\\Project"
+```