Multiple fixes and additional tests for persistence

.gitattributes

@@ -0,0 +1 @@
+*.json -diff

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

@@ -23,7 +23,7 @@
 
 namespace Microsoft.Python.Analysis.Analyzer.Evaluation {
     internal sealed partial class ExpressionEval {
-        public IPythonInstance GetConstantFromLiteral(Expression expr, LookupOptions options) {
+        public IPythonInstance GetConstantFromLiteral(Expression expr) {
             if (expr is ConstantExpression ce) {
                 switch (ce.Value) {
                     case string s:

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

@@ -189,7 +189,7 @@ public IMember GetValueFromExpression(Expression expr, LookupOptions options = L
                     m = null;
                     break;
                 default:
-                    m = GetValueFromBinaryOp(expr) ?? GetConstantFromLiteral(expr, options);
+                    m = GetValueFromBinaryOp(expr) ?? GetConstantFromLiteral(expr);
                     break;
             }
             if (m == null) {
@@ -237,29 +237,32 @@ private IMember GetValueFromMember(MemberExpression expr) {
                 return null;
             }
 
-            IPythonInstance instance = null;
             var m = GetValueFromExpression(expr.Target);
-            if (m is IPythonType typeInfo) {
-                var member = typeInfo.GetMember(expr.Name);
-                // If container is class/type info rather than the instance, then the method is an unbound function.
-                // Example: C.f where f is a method of C. Compare to C().f where f is bound to the instance of C.
-                if (member is PythonFunctionType f && !f.IsStatic && !f.IsClassMethod) {
-                    f.AddReference(GetLocationOfName(expr));
-                    return f.ToUnbound();
-                }
-                instance = new PythonInstance(typeInfo);
+            if (m == null) {
+                return UnknownType;
             }
 
-            instance = instance ?? m as IPythonInstance;
-            var type = m?.GetPythonType(); // Try inner type
-
+            var type = m.GetPythonType();
             var value = type?.GetMember(expr.Name);
             type?.AddMemberReference(expr.Name, this, GetLocationOfName(expr));
 
             if (type is IPythonModule) {
                 return value;
             }
 
+            IPythonInstance instance = null;
+            if (m == type) {
+                // If container is class/type info rather than the instance, then the method is an unbound function.
+                // Example: C.f where f is a method of C. Compare to C().f where f is bound to the instance of C.
+                if (value is PythonFunctionType f && f.DeclaringType != null && !f.IsStatic && !f.IsClassMethod) {
+                    f.AddReference(GetLocationOfName(expr));
+                    return f.ToUnbound();
+                }
+                instance = new PythonInstance(type);
+            }
+
+            instance = instance ?? m as IPythonInstance;
+
             // Class type GetMember returns a type. However, class members are
             // mostly instances (consider self.x = 1, x is an instance of int).
             // However, it is indeed possible to have them as types, like in

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

@@ -13,123 +13,18 @@
 // See the Apache Version 2.0 License for specific language governing
 // permissions and limitations under the License.
 
-using System;
-using System.Linq;
 using Microsoft.Python.Core.OS;
-using Microsoft.Python.Parsing;
 using Microsoft.Python.Parsing.Ast;
 
 namespace Microsoft.Python.Analysis.Analyzer.Handlers {
     internal sealed class ConditionalHandler : StatementHandler {
         private readonly IOSPlatform _platformService;
 
-        private enum ConditionTestResult {
-            Unrecognized,
-            DontWalkBody,
-            WalkBody
-        }
-
         public ConditionalHandler(AnalysisWalker walker) : base(walker) {
             _platformService = Eval.Services.GetService<IOSPlatform>();
         }
 
-        public bool HandleIf(IfStatement node) {
-            // System version, platform and os.path specializations
-            var someRecognized = false;
-            foreach (var test in node.Tests) {
-                var result = TryHandleSysVersionInfo(test);
-                if (result != ConditionTestResult.Unrecognized) {
-                    if (result == ConditionTestResult.WalkBody) {
-                        test.Walk(Walker);
-                    }
-                    someRecognized = true;
-                    continue;
-                }
-
-                result = TryHandleSysPlatform(test);
-                if (result != ConditionTestResult.Unrecognized) {
-                    if (result == ConditionTestResult.WalkBody) {
-                        test.Walk(Walker);
-                    }
-                    someRecognized = true;
-                    continue;
-                }
-
-                result = TryHandleOsPath(test);
-                if (result != ConditionTestResult.Unrecognized) {
-                    if (result == ConditionTestResult.WalkBody) {
-                        test.Walk(Walker);
-                        return false; // Execute only one condition.
-                    }
-                    someRecognized = true;
-                }
-            }
-            return !someRecognized;
-        }
-
-        private ConditionTestResult TryHandleSysVersionInfo(IfStatementTest test) {
-            if (test.Test is BinaryExpression cmp &&
-                cmp.Left is MemberExpression me && (me.Target as NameExpression)?.Name == "sys" && me.Name == "version_info" &&
-                cmp.Right is TupleExpression te && te.Items.All(i => (i as ConstantExpression)?.Value is int)) {
-                Version v;
-                try {
-                    v = new Version(
-                        (int)((te.Items.ElementAtOrDefault(0) as ConstantExpression)?.Value ?? 0),
-                        (int)((te.Items.ElementAtOrDefault(1) as ConstantExpression)?.Value ?? 0)
-                    );
-                } catch (ArgumentException) {
-                    // Unsupported comparison, so walk all children
-                    return ConditionTestResult.WalkBody;
-                }
-
-                var shouldWalk = false;
-                switch (cmp.Operator) {
-                    case PythonOperator.LessThan:
-                        shouldWalk = Ast.LanguageVersion.ToVersion() < v;
-                        break;
-                    case PythonOperator.LessThanOrEqual:
-                        shouldWalk = Ast.LanguageVersion.ToVersion() <= v;
-                        break;
-                    case PythonOperator.GreaterThan:
-                        shouldWalk = Ast.LanguageVersion.ToVersion() > v;
-                        break;
-                    case PythonOperator.GreaterThanOrEqual:
-                        shouldWalk = Ast.LanguageVersion.ToVersion() >= v;
-                        break;
-                }
-                return shouldWalk ? ConditionTestResult.WalkBody : ConditionTestResult.DontWalkBody;
-            }
-            return ConditionTestResult.Unrecognized;
-        }
-
-        private ConditionTestResult TryHandleSysPlatform(IfStatementTest test) {
-            if (test.Test is BinaryExpression cmp &&
-                cmp.Left is MemberExpression me && (me.Target as NameExpression)?.Name == "sys" && me.Name == "platform" &&
-                cmp.Right is ConstantExpression cex && cex.GetStringValue() is string s) {
-                switch (cmp.Operator) {
-                    case PythonOperator.Equals:
-                        return s == "win32" && _platformService.IsWindows ? ConditionTestResult.WalkBody : ConditionTestResult.DontWalkBody;
-                    case PythonOperator.NotEquals:
-                        return s == "win32" && _platformService.IsWindows ? ConditionTestResult.DontWalkBody : ConditionTestResult.WalkBody;
-                }
-                return ConditionTestResult.DontWalkBody;
-            }
-            return ConditionTestResult.Unrecognized;
-        }
-
-        private ConditionTestResult TryHandleOsPath(IfStatementTest test) {
-            if (test.Test is BinaryExpression cmp &&
-                cmp.Left is ConstantExpression cex && cex.GetStringValue() is string s &&
-                cmp.Right is NameExpression nex && nex.Name == "_names") {
-                switch (cmp.Operator) {
-                    case PythonOperator.In when s == "nt":
-                        return _platformService.IsWindows ? ConditionTestResult.WalkBody : ConditionTestResult.DontWalkBody;
-                    case PythonOperator.In when s == "posix":
-                        return _platformService.IsWindows ? ConditionTestResult.DontWalkBody : ConditionTestResult.WalkBody;
-                }
-                return ConditionTestResult.DontWalkBody;
-            }
-            return ConditionTestResult.Unrecognized;
-        }
+        public bool HandleIf(IfStatement node)
+            => node.WalkIfWithSystemConditions(Walker, Ast.LanguageVersion, _platformService.IsWindows);
     }
 }

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

@@ -40,10 +40,16 @@ public bool HandleFromImport(FromImportStatement node) {
                 }
             }
 
-            var imports = ModuleResolution.CurrentPathResolver.FindImports(Module.FilePath, node);
-            if (HandleImportSearchResult(imports, null, null, node.Root, out var variableModule)) {
-                AssignVariables(node, imports, variableModule);
+            if(node.Root is RelativeModuleName) {
+                var imports = ModuleResolution.CurrentPathResolver.FindImports(Module.FilePath, node);
+                if (HandleImportSearchResult(imports, null, null, node.Root, out var variableModule)) {
+                    AssignVariables(node, imports, variableModule);
+                }
+            } else {
+                FindModuleByAbsoluteName(node.Root, null, node.ForceAbsolute, out _, out var module, out _, out var imports);
+                AssignVariables(node, imports, module);
             }
+
             return false;
         }
 
@@ -82,7 +88,7 @@ private void HandleModuleImportStar(PythonVariableModule variableModule, bool is
             }
 
             // If __all__ is present, take it, otherwise declare all members from the module that do not begin with an underscore.
-            var memberNames = isImplicitPackage 
+            var memberNames = isImplicitPackage
                 ? variableModule.GetMemberNames()
                 : variableModule.Analysis.StarImportMemberNames ?? variableModule.GetMemberNames().Where(s => !s.StartsWithOrdinal("_"));
 

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

@@ -50,16 +50,30 @@ public bool HandleImport(ImportStatement node) {
         }
 
         private void HandleImport(ModuleName moduleImportExpression, NameExpression asNameExpression, bool forceAbsolute) {
+            FindModuleByAbsoluteName(moduleImportExpression, asNameExpression, forceAbsolute, out var firstModule, out var lastModule, out var importNames, out _);
+            // "import fob.oar.baz as baz" is handled as baz = import_module('fob.oar.baz')
+            // "import fob.oar.baz" is handled as fob = import_module('fob')
+            if (!string.IsNullOrEmpty(asNameExpression?.Name) && lastModule != default) {
+                Eval.DeclareVariable(asNameExpression.Name, lastModule, VariableSource.Import, asNameExpression);
+            } else if (firstModule != default && !string.IsNullOrEmpty(importNames[0])) {
+                var firstName = moduleImportExpression.Names[0];
+                Eval.DeclareVariable(importNames[0], firstModule, VariableSource.Import, firstName);
+            }
+        }
+
+        private void FindModuleByAbsoluteName(ModuleName moduleImportExpression, NameExpression asNameExpression, bool forceAbsolute,
+            out PythonVariableModule firstModule, out PythonVariableModule lastModule, out ImmutableArray<string> importNames, out IImportSearchResult imports) {
             // "import fob.oar.baz" means
             // import_module('fob')
             // import_module('fob.oar')
             // import_module('fob.oar.baz')
-            var importNames = ImmutableArray<string>.Empty;
-            var lastModule = default(PythonVariableModule);
-            var firstModule = default(PythonVariableModule);
+            importNames = ImmutableArray<string>.Empty;
+            lastModule = default;
+            firstModule = default;
+            imports = null;
             foreach (var nameExpression in moduleImportExpression.Names) {
                 importNames = importNames.Add(nameExpression.Name);
-                var imports = ModuleResolution.CurrentPathResolver.GetImportsFromAbsoluteName(Module.FilePath, importNames, forceAbsolute);
+                imports = ModuleResolution.CurrentPathResolver.GetImportsFromAbsoluteName(Module.FilePath, importNames, forceAbsolute);
                 if (!HandleImportSearchResult(imports, lastModule, asNameExpression, moduleImportExpression, out lastModule)) {
                     lastModule = default;
                     break;
@@ -69,15 +83,6 @@ private void HandleImport(ModuleName moduleImportExpression, NameExpression asNa
                     firstModule = lastModule;
                 }
             }
-
-            // "import fob.oar.baz as baz" is handled as baz = import_module('fob.oar.baz')
-            // "import fob.oar.baz" is handled as fob = import_module('fob')
-            if (!string.IsNullOrEmpty(asNameExpression?.Name) && lastModule != default) {
-                Eval.DeclareVariable(asNameExpression.Name, lastModule, VariableSource.Import, asNameExpression);
-            } else if (firstModule != default && !string.IsNullOrEmpty(importNames[0])) {
-                var firstName = moduleImportExpression.Names[0];
-                Eval.DeclareVariable(importNames[0], firstModule, VariableSource.Import, firstName);
-            }
         }
 
         private bool HandleImportSearchResult(in IImportSearchResult imports, in PythonVariableModule parent, in NameExpression asNameExpression, in Node location, out PythonVariableModule variableModule) {

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

@@ -15,12 +15,9 @@
 
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.Python.Analysis.Analyzer.Evaluation;
 using Microsoft.Python.Analysis.Diagnostics;
 using Microsoft.Python.Analysis.Documents;
-using Microsoft.Python.Analysis.Modules;
 using Microsoft.Python.Analysis.Values;
-using Microsoft.Python.Core;
 using Microsoft.Python.Core.Diagnostics;
 using Microsoft.Python.Parsing.Ast;