PTVS integration (#524)

* Clean up Completions, Find References and Hover unit tests.

* Initial commit

* CoreProduct buildable

* Product buildable except IronPython

* Move VS-specific file

* add hack to prevent True/False/None/... from being use-before-def (#464)

* Fix for extra paths inside workspace (#467)

Fix #281: Support "go to definition" for namespace packages
Fix #466: Fix "go to definition" and resolving imports

The fix is to put user search paths in front of workspace directory so that modules inside extra paths can be used as roots for packages

* Last port

* - Add nuspec
- Fix #501: PTVS-LS Integration: Fix LS hanging during file changes
- Fix #502: PTVS-LS Integration: Add required *.py files to the vsix

* Address CR comments

Author: AlexanderSher

src/Analysis/Engine/Impl/Analyzer/ExpressionEvaluator.cs

@@ -149,8 +149,19 @@ public IAnalysisSet LookupAnalysisSetByName(Node node, string name, bool addRef
                         refs = createIn.CreateVariable(node, _unit, name, addRef);
                         res = refs.Types;
                     } else {
-                        // ... warn the user
-                        warn = true;
+                        switch (name) {
+                            // "atom" in Python grammar.
+                            case "True":
+                            case "False":
+                            case "None":
+                            case "...":
+                                Debug.Fail($"Known good name '{name}' not found in scope");
+                                break;
+                            default:
+                                // ... warn the user
+                                warn = true;
+                                break;
+                        }
                     }
                 }
             }

src/Analysis/Engine/Impl/Definitions/IGroupableAnalysisProjectEntry.cs

@@ -22,14 +22,14 @@ namespace Microsoft.PythonTools.Analysis {
     /// more efficient analysis.
     /// 
     /// To analyze the full group you call Analyze(true) on all the items in the same group (determined
-    /// by looking at the identity of the AnalysGroup object).  Then you call AnalyzeQueuedEntries on the
+    /// by looking at the identity of the AnalysisGroup object).  Then you call AnalyzeQueuedEntries on the
     /// group.
     /// </summary>
     public interface IGroupableAnalysisProjectEntry {
         /// <summary>
         /// Analyzes this project entry optionally just adding it to the queue shared by the project.
         /// </summary>
-        void Analyze(CancellationToken cancel, bool enqueueOnly);
+        void PreAnalyze();
 
         IGroupableAnalysisProject AnalysisGroup { get; }
     }

src/Analysis/Engine/Impl/DependencyResolution/PathResolverSnapshot.cs

@@ -359,11 +359,11 @@ private void CreateRootsWithDefault(string rootDirectory, string[] userSearchPat
                 .ToArray();
 
             var filteredInterpreterSearchPaths = interpreterSearchPaths.Select(FixPath)
-                .Except(filteredUserSearchPaths.Prepend(rootDirectory))
+                .Except(filteredUserSearchPaths.Append(rootDirectory))
                 .ToArray();
 
             userRootsCount = filteredUserSearchPaths.Length + 1;
-            nodes = AddRootsFromSearchPaths(ImmutableArray<Node>.Empty.Add(GetOrCreateRoot(rootDirectory)), filteredUserSearchPaths, filteredInterpreterSearchPaths);
+            nodes = AddRootsFromSearchPaths(rootDirectory, filteredUserSearchPaths, filteredInterpreterSearchPaths);
 
             string FixPath(string p) => Path.IsPathRooted(p) ? PathUtils.NormalizePath(p) : PathUtils.NormalizePath(Path.Combine(rootDirectory, p));
         }
@@ -381,11 +381,18 @@ private void CreateRootsWithoutDefault(string[] userSearchPaths, string[] interp
                 .ToArray();
 
             userRootsCount = filteredUserSearchPaths.Length;
-            nodes = AddRootsFromSearchPaths(ImmutableArray<Node>.Empty, filteredUserSearchPaths, filteredInterpreterSearchPaths);
+            nodes = AddRootsFromSearchPaths(filteredUserSearchPaths, filteredInterpreterSearchPaths);
         }
 
-        private ImmutableArray<Node> AddRootsFromSearchPaths(ImmutableArray<Node> roots, string[] userSearchPaths, string[] interpreterSearchPaths) {
-            return roots
+        private ImmutableArray<Node> AddRootsFromSearchPaths(string rootDirectory, string[] userSearchPaths, string[] interpreterSearchPaths) {
+            return ImmutableArray<Node>.Empty
+                .AddRange(userSearchPaths.Select(GetOrCreateRoot).ToArray())
+                .Add(GetOrCreateRoot(rootDirectory))
+                .AddRange(interpreterSearchPaths.Select(GetOrCreateRoot).ToArray());
+        }
+
+        private ImmutableArray<Node> AddRootsFromSearchPaths(string[] userSearchPaths, string[] interpreterSearchPaths) {
+            return ImmutableArray<Node>.Empty
                 .AddRange(userSearchPaths.Select(GetOrCreateRoot).ToArray())
                 .AddRange(interpreterSearchPaths.Select(GetOrCreateRoot).ToArray());
         }

src/Analysis/Engine/Impl/Infrastructure/Extensions/StackExtensions.cs

@@ -0,0 +1,31 @@
+// Python Tools for Visual Studio
+// Copyright(c) Microsoft Corporation
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the License); you may not use
+// this file except in compliance with the License. You may obtain a copy of the
+// License at http://www.apache.org/licenses/LICENSE-2.0
+//
+// THIS CODE IS PROVIDED ON AN  *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS
+// OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY
+// IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+// MERCHANTABILITY OR NON-INFRINGEMENT.
+//
+// See the Apache Version 2.0 License for specific language governing
+// permissions and limitations under the License.
+
+using System.Collections.Generic;
+
+namespace Microsoft.PythonTools.Analysis.Infrastructure {
+    internal static class StackExtensions {
+        public static bool TryPeek<T>(this Stack<T> stack, out T result) {
+            if (stack.Count == 0) {
+                result = default;
+                return false;
+            }
+
+            result = stack.Peek();
+            return true;
+        }
+    }
+}

src/Analysis/Engine/Impl/Intellisense/AnalysisQueue.cs

@@ -137,6 +137,8 @@ public void Enqueue(IAnalyzable item, AnalysisPriority priority) {
         }
 
         private async Task HandleAnalyzable(IAnalyzable item, AnalysisPriority priority, CancellationToken cancellationToken) {
+            cancellationToken.ThrowIfCancellationRequested();
+
             if (item is IGroupableAnalysisProjectEntry groupable) {
                 var added = _enqueuedGroups.Add(groupable.AnalysisGroup);
                 if (added) {
@@ -147,7 +149,7 @@ private async Task HandleAnalyzable(IAnalyzable item, AnalysisPriority priority,
                     }
                 }
 
-                groupable.Analyze(cancellationToken, true);
+                groupable.PreAnalyze();
             } else {
                 item.Analyze(cancellationToken);
             }

src/Analysis/Engine/Impl/Interpreter/Definitions/PythonMemberType.cs

@@ -64,7 +64,6 @@ public enum PythonMemberType {
         /// An instance of a namespace object that was imported from .NET.
         /// </summary>
         Namespace,
-
         /// <summary>
         /// A constant defined in source code.
         /// </summary>

src/Analysis/Engine/Impl/Interpreter/InterpreterConfiguration.cs

@@ -21,7 +21,7 @@
 using Microsoft.PythonTools.Analysis.Infrastructure;
 
 namespace Microsoft.PythonTools.Interpreter {
-    public sealed class InterpreterConfiguration : IEquatable<InterpreterConfiguration> {
+    public class InterpreterConfiguration : IEquatable<InterpreterConfiguration> {
         private readonly string _description;
         private string _fullDescription;
 
@@ -48,29 +48,6 @@ public InterpreterConfiguration(
             SitePackagesPath = sitePackagesPath ?? string.Empty;
         }
 
-        [Obsolete]
-        public InterpreterConfiguration(
-            string id,
-            string description,
-            string prefixPath = null,
-            string path = null,
-            string winPath = "",
-            string pathVar = "",
-            InterpreterArchitecture arch = default(InterpreterArchitecture),
-            Version version = null,
-            InterpreterUIMode uiMode = InterpreterUIMode.Normal
-        ) {
-            Id = id;
-            _description = description ?? "";
-            PrefixPath = prefixPath;
-            InterpreterPath = path;
-            WindowsInterpreterPath = string.IsNullOrEmpty(winPath) ? path : winPath;
-            PathEnvironmentVariable = pathVar;
-            Architecture = arch ?? InterpreterArchitecture.Unknown;
-            Version = version ?? new Version();
-            UIMode = uiMode;
-        }
-
         private static string Read(Dictionary<string, object> d, string k)
             => d.TryGetValue(k, out var o) ? o as string : null;
 
@@ -155,22 +132,12 @@ public void SwitchToFullDescription() {
             }
         }
 
-        [Obsolete("Prefix path only applies to Windows.")]
-        public string PrefixPath { get; }
-
         /// <summary>
         /// Returns the path to the interpreter executable for launching Python
         /// applications.
         /// </summary>
         public string InterpreterPath { get; }
-
-        /// <summary>
-        /// Returns the path to the interpreter executable for launching Python
-        /// applications which are windows applications (pythonw.exe, ipyw.exe).
-        /// </summary>
-        [Obsolete("Python Language Server is platform-agnostic and does not use Windows-specific settings.")]
-        public string WindowsInterpreterPath { get; }
-
+        
         /// <summary>
         /// Gets the environment variable which should be used to set sys.path.
         /// </summary>
@@ -198,12 +165,6 @@ public void SwitchToFullDescription() {
         /// </summary>
         public string SitePackagesPath { get; }
 
-        /// <summary>
-        /// The UI behavior of the interpreter.
-        /// </summary>
-        [Obsolete("Language Server does not support UI features related to the interpreter.")]
-        public InterpreterUIMode UIMode { get; }
-
         /// <summary>
         /// The fixed search paths of the interpreter.
         /// </summary>

src/Analysis/Engine/Impl/Interpreter/InterpreterUIMode.cs

@@ -18,7 +18,7 @@
 using System.Collections.Generic;
 
 namespace Microsoft.PythonTools.Analysis {
-    internal class LocationInfo : ILocationInfo, IEquatable<LocationInfo> {
+    public class LocationInfo : ILocationInfo, IEquatable<LocationInfo> {
         internal static readonly LocationInfo[] Empty = new LocationInfo[0];
 
         public LocationInfo(string path, Uri documentUri, int line, int column) :