Language server using new analysis

src/Analysis/Ast/Impl/Analyzer/AnalysisWalker.cs

@@ -30,7 +30,6 @@ namespace Microsoft.Python.Analysis.Analyzer {
     /// </summary>
     internal abstract class AnalysisWalker : PythonWalkerAsync {
         protected ImportHandler ImportHandler { get; }
-        protected FromImportHandler FromImportHandler { get; }
         protected LoopHandler LoopHandler { get; }
         protected ConditionalHandler ConditionalHandler { get; }
         protected AssignmentHandler AssignmentHandler { get; }
@@ -47,7 +46,6 @@ internal abstract class AnalysisWalker : PythonWalkerAsync {
         protected AnalysisWalker(ExpressionEval eval) {
             Eval = eval;
             ImportHandler = new ImportHandler(this);
-            FromImportHandler = new FromImportHandler(this);
             AssignmentHandler = new AssignmentHandler(this);
             LoopHandler = new LoopHandler(this);
             ConditionalHandler = new ConditionalHandler(this);
@@ -77,7 +75,7 @@ public override async Task<bool> WalkAsync(ForStatement node, CancellationToken
         }
 
         public override Task<bool> WalkAsync(FromImportStatement node, CancellationToken cancellationToken = default)
-            => FromImportHandler.HandleFromImportAsync(node, cancellationToken);
+            => ImportHandler.HandleFromImportAsync(node, cancellationToken);
 
         public override Task<bool> WalkAsync(GlobalStatement node, CancellationToken cancellationToken = default)
             => NonLocalHandler.HandleGlobalAsync(node, cancellationToken);

src/Analysis/Ast/Impl/Analyzer/Definitions/IAnalyzable.cs

@@ -13,6 +13,8 @@
 // See the Apache Version 2.0 License for specific language governing
 // permissions and limitations under the License.
 
+using System;
+
 namespace Microsoft.Python.Analysis.Analyzer {
     /// <summary>
     /// Represents document that can be analyzed asynchronously.
@@ -40,8 +42,17 @@ internal interface IAnalyzable {
         /// Notifies document that its analysis is now complete.
         /// </summary>
         /// <param name="analysis">Document analysis</param>
-        /// (version of the snapshot in the beginning of analysis).</param>
         /// <returns>True if analysis was accepted, false if is is out of date.</returns>
         bool NotifyAnalysisComplete(IDocumentAnalysis analysis);
+
+        /// <summary>
+        /// Notifies module that analysis has been canceled.
+        /// </summary>
+        void NotifyAnalysisCanceled();
+
+        /// <summary>
+        /// Notifies module that analysis has thrown an exception.
+        /// </summary>
+        void NotifyAnalysisFailed(Exception ex);
     }
 }

src/Analysis/Ast/Impl/Analyzer/Definitions/IExpressionEvaluator.cs

@@ -0,0 +1,70 @@
+// 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;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Python.Analysis.Types;
+using Microsoft.Python.Analysis.Values;
+using Microsoft.Python.Core;
+using Microsoft.Python.Parsing.Ast;
+
+namespace Microsoft.Python.Analysis.Analyzer {
+    public interface IExpressionEvaluator {
+        /// <summary>
+        /// Opens existing scope for a node. The scope is pushed
+        /// on the stack and will be removed when the returned
+        /// disposable is disposed.
+        /// </summary>
+        IDisposable OpenScope(IScope scope);
+
+        /// <summary>
+        /// Opens existing scope for a node. The scope is pushed
+        /// on the stack and will be removed when the returned
+        /// disposable is disposed.
+        /// </summary>
+        IDisposable OpenScope(IPythonModule module, ScopeStatement scope);
+
+        /// <summary>
+        /// Currently opened (deep-most) scope.
+        /// </summary>
+        IScope CurrentScope { get; }
+
+        /// <summary>
+        /// Module global scope.
+        /// </summary>
+        IGlobalScope GlobalScope { get; }
+
+        /// <summary>
+        /// Determines node location in the module source code.
+        /// </summary>
+        LocationInfo GetLocation(Node node);
+
+        /// <summary>
+        /// Evaluates expression in the currently open scope.
+        /// </summary>
+        Task<IMember> GetValueFromExpressionAsync(Expression expr, CancellationToken cancellationToken = default);
+
+        IMember LookupNameInScopes(string name, out IScope scope);
+
+        IPythonType GetTypeFromPepHint(Node node);
+        IPythonType GetTypeFromString(string typeString);
+
+        PythonAst Ast { get; }
+        IPythonModule Module { get; }
+        IPythonInterpreter Interpreter { get; }
+        IServiceContainer Services { get; }
+    }
+}

src/Analysis/Ast/Impl/Analyzer/DocumentAnalysis.cs

@@ -13,28 +13,31 @@
 // See the Apache Version 2.0 License for specific language governing
 // permissions and limitations under the License.
 
+using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
+using Microsoft.Python.Analysis.Analyzer.Evaluation;
+using Microsoft.Python.Analysis.Analyzer.Expressions;
 using Microsoft.Python.Analysis.Diagnostics;
 using Microsoft.Python.Analysis.Types;
 using Microsoft.Python.Analysis.Documents;
 using Microsoft.Python.Analysis.Values;
 using Microsoft.Python.Core;
 using Microsoft.Python.Core.Diagnostics;
 using Microsoft.Python.Core.Text;
+using Microsoft.Python.Parsing;
 using Microsoft.Python.Parsing.Ast;
 
 namespace Microsoft.Python.Analysis.Analyzer {
     internal sealed class DocumentAnalysis : IDocumentAnalysis {
-        public static readonly IDocumentAnalysis Empty = new EmptyAnalysis();
-
-        public DocumentAnalysis(IDocument document, int version, IGlobalScope globalScope, PythonAst ast) {
+        public DocumentAnalysis(IDocument document, int version, IGlobalScope globalScope, IExpressionEvaluator eval) {
             Check.ArgumentNotNull(nameof(document), document);
             Check.ArgumentNotNull(nameof(globalScope), globalScope);
             Document = document;
             Version = version;
             GlobalScope = globalScope;
-            Ast = ast;
+            ExpressionEvaluator = eval;
         }
 
         #region IDocumentAnalysis
@@ -53,47 +56,37 @@ public DocumentAnalysis(IDocument document, int version, IGlobalScope globalScop
         /// <summary>
         /// AST that was used in the analysis.
         /// </summary>
-        public PythonAst Ast { get; }
+        public PythonAst Ast => ExpressionEvaluator.Ast;
 
         /// <summary>
         /// Document/module global scope.
         /// </summary>
         public IGlobalScope GlobalScope { get; }
 
         /// <summary>
-        /// Module top-level members
-        /// </summary>
-        public IVariableCollection TopLevelVariables => GlobalScope.Variables;
-
-        /// <summary>
-        /// All module members from all scopes.
+        /// Expression evaluator used in the analysis.
         /// </summary>
-        public IEnumerable<IVariable> AllVariables
-            => (GlobalScope as IScope).TraverseBreadthFirst(s => s.Children).SelectMany(s => s.Variables);
-
-        public IEnumerable<IPythonType> GetAllAvailableItems(SourceLocation location) => Enumerable.Empty<IPythonType>();
-        public IEnumerable<IPythonType> GetMembers(SourceLocation location) => Enumerable.Empty<IPythonType>();
-        public IEnumerable<IPythonFunctionOverload> GetSignatures(SourceLocation location) => Enumerable.Empty<IPythonFunctionOverload>();
-        public IEnumerable<IPythonType> GetValues(SourceLocation location) => Enumerable.Empty<IPythonType>();
+        public IExpressionEvaluator ExpressionEvaluator { get; }
         #endregion
+    }
 
-        private sealed class EmptyAnalysis : IDocumentAnalysis {
-            public EmptyAnalysis(IDocument document = null) {
-                Document = document;
-                GlobalScope = new EmptyGlobalScope(document);
-            }
+    public sealed class EmptyAnalysis : IDocumentAnalysis {
+        private static PythonAst _emptyAst;
 
-            public IDocument Document { get; }
-            public int Version { get; } = -1;
-            public IGlobalScope GlobalScope { get; }
-            public PythonAst Ast => null;
-            public IEnumerable<IPythonType> GetAllAvailableItems(SourceLocation location) => Enumerable.Empty<IPythonType>();
-            public IEnumerable<DiagnosticsEntry> Diagnostics => Enumerable.Empty<DiagnosticsEntry>();
-            public IVariableCollection TopLevelVariables => VariableCollection.Empty;
-            public IEnumerable<IVariable> AllVariables => Enumerable.Empty<IVariable>();
-            public IEnumerable<IPythonType> GetMembers(SourceLocation location) => Enumerable.Empty<IPythonType>();
-            public IEnumerable<IPythonFunctionOverload> GetSignatures(SourceLocation location) => Enumerable.Empty<IPythonFunctionOverload>();
-            public IEnumerable<IPythonType> GetValues(SourceLocation location) => Enumerable.Empty<IPythonType>();
+        public EmptyAnalysis(IServiceContainer services, IDocument document) {
+            Document = document ?? throw new ArgumentNullException(nameof(document));
+            GlobalScope = new EmptyGlobalScope(document);
+
+            _emptyAst = _emptyAst ?? (_emptyAst = Parser.CreateParser(new StringReader(string.Empty), PythonLanguageVersion.None).ParseFile());
+            ExpressionEvaluator = new ExpressionEval(services, document, Ast);
         }
+
+        public IDocument Document { get; }
+        public int Version { get; } = -1;
+        public IGlobalScope GlobalScope { get; }
+        public PythonAst Ast => _emptyAst;
+        public IExpressionEvaluator ExpressionEvaluator { get; }
+        public IEnumerable<DiagnosticsEntry> Diagnostics => Enumerable.Empty<DiagnosticsEntry>();
     }
+
 }