Process class member definitions in order (#1108)

Author: Mikhail Arkhipov

src/Analysis/Ast/Impl/Analyzer/Symbols/ClassEvaluator.cs

@@ -86,19 +86,26 @@ private void ProcessClassBody() {
             foreach (var s in GetStatements<FromImportStatement>(_classDef)) {
                 ImportHandler.HandleFromImport(s);
             }
-
             foreach (var s in GetStatements<ImportStatement>(_classDef)) {
                 ImportHandler.HandleImport(s);
             }
-
             UpdateClassMembers();
 
             // Process assignments so we get class variables declared.
-            foreach (var s in GetStatements<AssignmentStatement>(_classDef)) {
-                AssignmentHandler.HandleAssignment(s);
-            }
-            foreach (var s in GetStatements<ExpressionStatement>(_classDef)) {
-                AssignmentHandler.HandleAnnotatedExpression(s.Expression as ExpressionWithAnnotation, null);
+            // Note that annotated definitions and assignments can be intermixed
+            // and must be processed in order. Consider
+            //    class A:
+            //      x: int
+            //      x = 1
+            foreach (var s in GetStatements<Statement>(_classDef)) {
+                switch (s) {
+                    case AssignmentStatement assignment:
+                        AssignmentHandler.HandleAssignment(assignment);
+                        break;
+                    case ExpressionStatement e:
+                        AssignmentHandler.HandleAnnotatedExpression(e.Expression as ExpressionWithAnnotation, null);
+                        break;
+                }
             }
             UpdateClassMembers();
 

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

@@ -611,6 +611,17 @@ public async Task GlobalScope() {
             d[0].SourceSpan.Should().Be(2, 7, 2, 16);
         }
 
+        [TestMethod, Priority(0)]
+        public async Task ClassMemberDefinition() {
+            const string code = @"
+class A:
+    i: int
+    i = 0
+";
+            var d = await LintAsync(code);
+            d.Should().BeEmpty();
+        }
+
         private async Task<IReadOnlyList<DiagnosticsEntry>> LintAsync(string code, InterpreterConfiguration configuration = null) {
             var analysis = await GetAnalysisAsync(code, configuration ?? PythonVersions.LatestAvailable3X);
             var a = Services.GetService<IPythonAnalyzer>();

src/Analysis/Ast/Test/LintUndefinedVarsTests.cs

@@ -269,6 +269,21 @@ def func(a: A):
             x.References[1].Span.Should().Be(6, 14, 6, 15);
         }
 
+        [TestMethod, Priority(0)]
+        public async Task ClassFieldAnnotation() {
+            const string code = @"
+class A:
+    x: int
+    x = 0
+";
+            var analysis = await GetAnalysisAsync(code);
+            var x = analysis.GlobalScope.Children[0].Should().HaveVariable("x").Which;
+            x.Should().NotBeNull();
+            x.References.Should().HaveCount(2);
+            x.References[0].Span.Should().Be(3, 5, 3, 6);
+            x.References[1].Span.Should().Be(4, 5, 4, 6);
+        }
+
         [TestMethod, Priority(0)]
         public async Task Assignments() {
             const string code = @"