Report unresolved imports

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

@@ -67,6 +67,8 @@ public interface IExpressionEvaluator {
         IPythonModule Module { get; }
         IPythonInterpreter Interpreter { get; }
         IServiceContainer Services { get; }
+
+        void ReportDiagnostics(Uri documentUri, DiagnosticsEntry entry);
         IEnumerable<DiagnosticsEntry> Diagnostics { get; }
     }
 }

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

@@ -18,14 +18,11 @@
 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;
 
@@ -67,6 +64,11 @@ public DocumentAnalysis(IDocument document, int version, IGlobalScope globalScop
         /// Expression evaluator used in the analysis.
         /// </summary>
         public IExpressionEvaluator ExpressionEvaluator { get; }
+
+        /// <summary>
+        /// Analysis diagnostics.
+        /// </summary>
+        public IEnumerable<DiagnosticsEntry> Diagnostics => ExpressionEvaluator.Diagnostics;
         #endregion
     }
 
@@ -88,5 +90,4 @@ public EmptyAnalysis(IServiceContainer services, IDocument document) {
         public IExpressionEvaluator ExpressionEvaluator { get; }
         public IEnumerable<DiagnosticsEntry> Diagnostics => Enumerable.Empty<DiagnosticsEntry>();
     }
-
 }

src/Analysis/Ast/Impl/Analyzer/Evaluation/ExpressionEval.cs

@@ -33,7 +33,7 @@ namespace Microsoft.Python.Analysis.Analyzer.Evaluation {
     /// Helper class that provides methods for looking up variables
     /// and types in a chain of scopes during analysis.
     /// </summary>
-    internal sealed partial class ExpressionEval : IExpressionEvaluator {
+    internal sealed partial class ExpressionEval: IExpressionEvaluator {
         private readonly Stack<Scope> _openScopes = new Stack<Scope>();
         private readonly List<DiagnosticsEntry> _diagnostics = new List<DiagnosticsEntry>();
         private readonly object _lock = new object();
@@ -229,11 +229,11 @@ private async Task<IMember> GetValueFromConditionalAsync(ConditionalExpression e
             return trueValue ?? falseValue;
         }
 
-        private void ReportDiagnostics(Uri documentUri, IEnumerable<DiagnosticsEntry> entries) {
+        public void ReportDiagnostics(Uri documentUri, DiagnosticsEntry entry) {
             // Do not add if module is library, etc. Only handle user code.
             if (Module.ModuleType == ModuleType.User) {
                 lock (_lock) {
-                    _diagnostics.AddRange(entries);
+                    _diagnostics.Add(entry);
                 }
             }
         }

src/Analysis/Ast/Impl/Analyzer/Handlers/FromImportHandler.cs

@@ -33,15 +33,14 @@ public async Task<bool> HandleFromImportAsync(FromImportStatement node, Cancella
             }
 
             var rootNames = node.Root.Names;
-            IImportSearchResult imports = null;
             if (rootNames.Count == 1) {
                 var rootName = rootNames[0].Name;
                 if (rootName.EqualsOrdinal("__future__")) {
                     return false;
                 }
             }
 
-            imports = ModuleResolution.CurrentPathResolver.FindImports(Module.FilePath, node);
+            var imports = ModuleResolution.CurrentPathResolver.FindImports(Module.FilePath, node);
             // If we are processing stub, ignore imports of the original module.
             // For example, typeshed stub for sys imports sys.
             if (Module.ModuleType == ModuleType.Stub && imports is ModuleImport mi && mi.Name == Module.Name) {
@@ -51,19 +50,21 @@ public async Task<bool> HandleFromImportAsync(FromImportStatement node, Cancella
             switch (imports) {
                 case ModuleImport moduleImport when moduleImport.FullName == Module.Name:
                     ImportMembersFromSelf(node);
-                    return false;
+                    break;
                 case ModuleImport moduleImport:
                     await ImportMembersFromModuleAsync(node, moduleImport.FullName, cancellationToken);
-                    return false;
+                    break;
                 case PossibleModuleImport possibleModuleImport:
-                    await HandlePossibleImportAsync(node, possibleModuleImport, cancellationToken);
-                    return false;
+                    await HandlePossibleImportAsync(possibleModuleImport, possibleModuleImport.PossibleModuleFullName, Eval.GetLoc(node.Root), cancellationToken);
+                    break;
                 case PackageImport packageImports:
                     await ImportMembersFromPackageAsync(node, packageImports, cancellationToken);
-                    return false;
-                default:
-                    return false;
+                    break;
+                case ImportNotFound notFound:
+                    MakeUnresolvedImport(null, notFound.FullName, Eval.GetLoc(node.Root));
+                    break;
             }
+            return false;
         }
 
         private void ImportMembersFromSelf(FromImportStatement node) {

src/Analysis/Ast/Impl/Analyzer/Handlers/ImportHandler.cs

@@ -18,13 +18,17 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Python.Analysis.Core.DependencyResolution;
+using Microsoft.Python.Analysis.Diagnostics;
 using Microsoft.Python.Analysis.Modules;
 using Microsoft.Python.Analysis.Types;
 using Microsoft.Python.Analysis.Values;
+using Microsoft.Python.Core;
+using Microsoft.Python.Parsing;
 using Microsoft.Python.Parsing.Ast;
+using ErrorCodes = Microsoft.Python.Analysis.Diagnostics.ErrorCodes;
 
 namespace Microsoft.Python.Analysis.Analyzer.Handlers {
-    internal sealed partial class ImportHandler: StatementHandler {
+    internal sealed partial class ImportHandler : StatementHandler {
         public ImportHandler(AnalysisWalker walker) : base(walker) { }
 
         public async Task<bool> HandleImportAsync(ImportStatement node, CancellationToken cancellationToken = default) {
@@ -48,20 +52,21 @@ public async Task<bool> HandleImportAsync(ImportStatement node, CancellationToke
                 }
 
                 var location = Eval.GetLoc(moduleImportExpression);
+                var moduleName = moduleImportExpression.MakeString();
                 IPythonModule module = null;
                 switch (imports) {
                     case ModuleImport moduleImport when moduleImport.FullName == Module.Name:
                         Eval.DeclareVariable(memberName, Module, VariableSource.Declaration, location);
                         break;
                     case ModuleImport moduleImport:
-                        module = await HandleImportAsync(node, moduleImport, cancellationToken);
+                        module = await HandleImportAsync(moduleImport, location, cancellationToken);
                         break;
                     case PossibleModuleImport possibleModuleImport:
-                        module = await HandlePossibleImportAsync(node, possibleModuleImport, cancellationToken);
+                        module = await HandlePossibleImportAsync(possibleModuleImport, moduleName, location, cancellationToken);
                         break;
                     default:
                         // TODO: Package import?
-                        MakeUnresolvedImport(memberName, moduleImportExpression);
+                        MakeUnresolvedImport(memberName, moduleName, Eval.GetLoc(moduleImportExpression));
                         break;
                 }
 
@@ -72,20 +77,21 @@ public async Task<bool> HandleImportAsync(ImportStatement node, CancellationToke
             return false;
         }
 
-        private async Task<IPythonModule> HandleImportAsync(ImportStatement node, ModuleImport moduleImport, CancellationToken cancellationToken) {
+        private async Task<IPythonModule> HandleImportAsync(ModuleImport moduleImport, LocationInfo location, CancellationToken cancellationToken) {
             var module = await ModuleResolution.ImportModuleAsync(moduleImport.FullName, cancellationToken);
             if (module == null) {
-                MakeUnresolvedImport(moduleImport.FullName, node);
+                MakeUnresolvedImport(moduleImport.FullName, moduleImport.FullName, location);
                 return null;
             }
             return module;
         }
 
-        private async Task<IPythonModule> HandlePossibleImportAsync(Node node, PossibleModuleImport possibleModuleImport, CancellationToken cancellationToken) {
+        private async Task<IPythonModule> HandlePossibleImportAsync(
+            PossibleModuleImport possibleModuleImport, string moduleName, LocationInfo location, CancellationToken cancellationToken) {
             var fullName = possibleModuleImport.PrecedingModuleFullName;
             var module = await ModuleResolution.ImportModuleAsync(possibleModuleImport.PrecedingModuleFullName, cancellationToken);
             if (module == null) {
-                MakeUnresolvedImport(possibleModuleImport.PrecedingModuleFullName, node);
+                MakeUnresolvedImport(possibleModuleImport.PrecedingModuleFullName, moduleName, location);
                 return null;
             }
 
@@ -95,7 +101,7 @@ private async Task<IPythonModule> HandlePossibleImportAsync(Node node, PossibleM
                 var childModule = module.GetMember<IPythonModule>(namePart);
                 if (childModule == null) {
                     var unresolvedModuleName = string.Join(".", nameParts.Take(i + 1).Prepend(fullName));
-                    MakeUnresolvedImport(unresolvedModuleName, node);
+                    MakeUnresolvedImport(unresolvedModuleName, moduleName, location);
                     return null;
                 }
                 module = childModule;
@@ -143,7 +149,12 @@ private void AssignImportedVariables(IPythonModule module, DottedName moduleImpo
             }
         }
 
-        private void MakeUnresolvedImport(string name, Node node)
-            => Eval.DeclareVariable(name, new SentinelModule(name, Eval.Services), VariableSource.Import, Eval.GetLoc(node));
+        private void MakeUnresolvedImport(string variableName, string moduleName, LocationInfo location) {
+            if (!string.IsNullOrEmpty(variableName)) {
+                Eval.DeclareVariable(variableName, new SentinelModule(moduleName, Eval.Services), VariableSource.Import, location);
+            }
+            Eval.ReportDiagnostics(Eval.Module.Uri, new DiagnosticsEntry(
+                Resources.ErrorUnresolvedImport.FormatInvariant(moduleName), location.Span, ErrorCodes.UnresolvedImport, Severity.Warning));
+        }
     }
 }

src/Analysis/Ast/Impl/Definitions/IDocumentAnalysis.cs

@@ -13,7 +13,9 @@
 // See the Apache Version 2.0 License for specific language governing
 // permissions and limitations under the License.
 
+using System.Collections.Generic;
 using Microsoft.Python.Analysis.Analyzer;
+using Microsoft.Python.Analysis.Diagnostics;
 using Microsoft.Python.Analysis.Documents;
 using Microsoft.Python.Analysis.Values;
 using Microsoft.Python.Parsing.Ast;
@@ -49,5 +51,10 @@ public interface IDocumentAnalysis {
         /// Expression evaluator used in the analysis.
         /// </summary>
         IExpressionEvaluator ExpressionEvaluator { get; }
+
+        /// <summary>
+        /// Analysis diagnostics.
+        /// </summary>
+        IEnumerable<DiagnosticsEntry> Diagnostics { get; }
     }
 }

src/Analysis/Ast/Impl/Diagnostics/DiagnosticsSeverityMap.cs

@@ -0,0 +1,45 @@
+// 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;
+using Microsoft.Python.Core;
+using Microsoft.Python.Parsing;
+
+namespace Microsoft.Python.Analysis.Diagnostics {
+    public sealed class DiagnosticsSeverityMap {
+        private readonly Dictionary<string, Severity> _map = new Dictionary<string, Severity>();
+
+        public DiagnosticsSeverityMap() { }
+
+        public DiagnosticsSeverityMap(string[] errors, string[] warnings, string[] information, string[] disabled) {
+            _map.Clear();
+            // disabled > error > warning > information
+            foreach (var x in information.MaybeEnumerate()) {
+                _map[x] = Severity.Information;
+            }
+            foreach (var x in warnings.MaybeEnumerate()) {
+                _map[x] = Severity.Warning;
+            }
+            foreach (var x in errors.MaybeEnumerate()) {
+                _map[x] = Severity.Error;
+            }
+            foreach (var x in disabled.MaybeEnumerate()) {
+                _map[x] = Severity.Suppressed;
+            }
+        }
+        public Severity GetEffectiveSeverity(string code, Severity defaultSeverity)
+            => _map.TryGetValue(code, out var severity) ? severity : defaultSeverity;
+    }
+}

src/Analysis/Ast/Impl/Diagnostics/ErrorCodes.cs

@@ -21,5 +21,6 @@ public static class ErrorCodes {
         public const string UnknownParameterName = "unknown-parameter-name";
         public const string ParameterAlreadySpecified = "parameter-already-specified";
         public const string ParameterMissing = "parameter-missing";
+        public const string UnresolvedImport = "unresolved-import";
     }
 }

src/Analysis/Ast/Impl/Diagnostics/IDiagnosticsService.cs

@@ -38,5 +38,12 @@ public interface IDiagnosticsService {
         /// the diagnostic publishing to the client.
         /// </summary>
         int PublishingDelay { get; set; }
+
+        /// <summary>
+        /// Provides map of error codes to severity when user wants
+        /// to override default severity settings or suppress particular
+        /// diagnostics completely.
+        /// </summary>
+        DiagnosticsSeverityMap DiagnosticsSeverityMap { get; set; }
     }
 }

src/Analysis/Ast/Impl/Modules/PythonModule.cs

@@ -385,7 +385,7 @@ private void Parse(CancellationToken cancellationToken) {
 
                 // Do not report issues with libraries or stubs
                 if (sink != null) {
-                    _diagnosticsService?.Replace(Uri, _parseErrors);
+                    _diagnosticsService?.Replace(Uri, _parseErrors.Concat(Analysis.Diagnostics));
                 }
 
                 _parsingTask = null;
@@ -460,6 +460,11 @@ public virtual bool NotifyAnalysisComplete(IDocumentAnalysis analysis) {
                     OnAnalysisComplete();
                     ContentState = State.Analyzed;
 
+                    // Do not report issues with libraries or stubs
+                    if (ModuleType == ModuleType.User) {
+                        _diagnosticsService?.Replace(Uri, _parseErrors.Concat(Analysis.Diagnostics));
+                    }
+
                     var tcs = _analysisTcs;
                     _analysisTcs = null;
                     tcs.TrySetResult(analysis);

src/Analysis/Ast/Impl/Modules/Resolution/MainModuleResolution.cs

@@ -42,7 +42,7 @@ internal async Task InitializeAsync(CancellationToken cancellationToken = defaul
 
             // Initialize built-in
             var moduleName = BuiltinTypeId.Unknown.GetModuleName(_interpreter.LanguageVersion);
-            var modulePath = ModuleCache.GetCacheFilePath(_interpreter.Configuration.InterpreterPath ?? "python.exe");
+            var modulePath = ModuleCache.GetCacheFilePath(_interpreter.Configuration.InterpreterPath);
 
             var b = new BuiltinsPythonModule(moduleName, modulePath, _services);
             _modules[BuiltinModuleName] = BuiltinsModule = b;

src/Analysis/Ast/Test/FluentAssertions/AssertionsFactory.cs

@@ -32,5 +32,8 @@ internal static class AssertionsFactory {
         public static VariableAssertions Should(this IVariable v) => new VariableAssertions(v);
 
         public static RangeAssertions Should(this Range? range) => new RangeAssertions(range);
+
+        public static SourceSpanAssertions Should(this SourceSpan span) => new SourceSpanAssertions(span);
+        public static SourceSpanAssertions Should(this SourceSpan? span) => new SourceSpanAssertions(span.Value);
     }
 }

src/LanguageServer/Test/FluentAssertions/SourceSpanAssertions.cs → src/Analysis/Ast/Test/FluentAssertions/SourceSpanAssertions.cs

@@ -18,8 +18,8 @@
 using Microsoft.Python.Core.Text;
 using static Microsoft.Python.Analysis.Tests.FluentAssertions.AssertionsUtilities;
 
-namespace Microsoft.Python.LanguageServer.Tests.FluentAssertions {
-    internal sealed class SourceSpanAssertions {
+namespace Microsoft.Python.Analysis.Tests.FluentAssertions {
+    public sealed class SourceSpanAssertions {
         public SourceSpan? Subject { get; }
 
         public SourceSpanAssertions(SourceSpan? span) {