Issue 44780. Fix reporing accessing instance from static when enclosed in local variable.

Bug: #44780
Change-Id: Iec59d928161b68ecf77f95792bd6e9ac8ca0d462
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/181305
Reviewed-by: Brian Wilkerson <[email protected]>
Reviewed-by: Samuel Rawlins <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/generated/error_verifier.dart

@@ -114,26 +114,28 @@ class EnclosingExecutableContext {
 
   DartType get returnType => catchErrorOnErrorReturnType ?? element.returnType;
 
-  static bool _inFactoryConstructor(ExecutableElement element) {
+  static bool _inFactoryConstructor(Element element) {
+    var enclosing = element?.enclosingElement;
+    if (enclosing == null) {
+      return false;
+    }
     if (element is ConstructorElement) {
       return element.isFactory;
     }
-    var enclosing = element?.enclosingElement;
-    if (enclosing is ExecutableElement) {
-      return _inFactoryConstructor(enclosing);
-    }
-    return false;
+    return _inFactoryConstructor(enclosing);
   }
 
-  static bool _inStaticMethod(ExecutableElement element) {
+  static bool _inStaticMethod(Element element) {
     var enclosing = element?.enclosingElement;
-    if (enclosing is ClassElement || enclosing is ExtensionElement) {
-      return element.isStatic;
+    if (enclosing == null) {
+      return false;
     }
-    if (enclosing is ExecutableElement) {
-      return _inStaticMethod(enclosing);
+    if (enclosing is ClassElement || enclosing is ExtensionElement) {
+      if (element is ExecutableElement) {
+        return element.isStatic;
+      }
     }
-    return false;
+    return _inStaticMethod(enclosing);
   }
 }
 

pkg/analyzer/test/src/diagnostics/instance_member_access_from_factory_test.dart

@@ -15,66 +15,97 @@ main() {
 
 @reflectiveTest
 class InstanceMemberAccessFromFactoryTest extends PubPackageResolutionTest {
-  test_named() async {
+  test_named_getter() async {
     await assertErrorsInCode(r'''
 class A {
-  m() {}
-  A();
+  int get foo => 0;
+
   factory A.make() {
-    m();
-    return new A();
+    foo;
+    throw 0;
   }
 }
 ''', [
-      error(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, 51, 1),
+      error(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, 56, 3),
     ]);
   }
 
-  test_property() async {
+  test_named_getter_localFunction() async {
     await assertErrorsInCode(r'''
 class A {
-  int m;
-  A();
+  int get foo => 0;
+
   factory A.make() {
-    m;
-    return new A();
+    void f() {
+      foo;
+    }
+    f();
+    throw 0;
   }
 }
 ''', [
-      error(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, 51, 1),
+      error(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, 73, 3),
     ]);
   }
 
-  test_property_fromClosure() async {
+  test_named_method() async {
     await assertErrorsInCode(r'''
 class A {
-  int m;
-  A();
+  void foo() {}
+
   factory A.make() {
-    void f() {
-      m;
-    }
-    f();
-    return new A();
+    foo();
+    throw 0;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, 52, 3),
+    ]);
+  }
+
+  test_named_method_functionExpression() async {
+    await assertErrorsInCode(r'''
+class A {
+  void foo() {}
+
+  factory A.make() {
+    () => foo();
+    throw 0;
   }
 }
 ''', [
-      error(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, 68, 1),
+      error(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, 58, 3),
     ]);
   }
 
-  test_unnamed() async {
+  test_named_method_functionExpression_localVariable() async {
     await assertErrorsInCode(r'''
 class A {
-  m() {}
-  A._();
+  void foo() {}
+
+  factory A.make() {
+    // ignore:unused_local_variable
+    var x = () => foo();
+    throw 0;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, 102, 3),
+    ]);
+  }
+
+  test_unnamed_method() async {
+    await assertErrorsInCode(r'''
+class A {
+  void foo() {}
+
   factory A() {
-    m();
-    return new A._();
+    foo();
+    throw 0;
   }
 }
 ''', [
-      error(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, 48, 1),
+      error(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, 47, 3),
     ]);
   }
 }

pkg/analyzer/test/src/diagnostics/instance_member_access_from_static_test.dart

@@ -61,6 +61,35 @@ class A {
     ]);
   }
 
+  test_class_thisGetter_fromMethod_functionExpression() async {
+    await assertErrorsInCode(r'''
+class A {
+  int get foo => 0;
+
+  static void bar() {
+    () => foo;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC, 63, 3),
+    ]);
+  }
+
+  test_class_thisGetter_fromMethod_functionExpression_localVariable() async {
+    await assertErrorsInCode(r'''
+class A {
+  int get foo => 0;
+
+  static void bar() {
+    // ignore:unused_local_variable
+    var x = () => foo;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC, 107, 3),
+    ]);
+  }
+
   test_class_thisMethod_fromMethod() async {
     await assertErrorsInCode(r'''
 class A {