Fix analyzer interpretation of 'ClassName?.staticMember'.

pkg/analyzer/test/generated/non_error_resolver_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.non_error_resolver_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
-import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:unittest/unittest.dart' as _ut;
 
 import '../reflective_tests.dart';
 import 'resolver_test.dart';
 import 'test_support.dart';
 
 main() {
@@ skipping 4975 matching lines @@
 }
 class Bar extends Foo {
   Bar() : this.ctor();
   Bar.ctor() : super.ctor();
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_undefinedGetter_typeLiteral_conditionalAccess() {
-    // When applied to a type literal, the conditional access operator '?.' can
-    // be used to access instance getters of Type.
+  void test_undefinedGetter_static_conditionalAccess() {
+    // The conditional access operator '?.' can be used to access static
+    // fields.
     Source source = addSource('''
-class A {}
-f() => A?.hashCode;
+class A {
+  static var x;
+}
+var a = A?.x;
 ''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_undefinedGetter_typeSubstitution() {
     Source source = addSource(r'''
 class A<E> {
   E element;
@@ skipping 61 matching lines @@
   void test_undefinedMethod_functionExpression_directCall() {
     Source source = addSource(r'''
 main() {
   (() => null)();
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     // A call to verify(source) fails as '(() => null)()' isn't resolved.
   }
 
-  void test_undefinedMethod_typeLiteral_conditionalAccess() {
-    // When applied to a type literal, the conditional access operator '?.' can
-    // be used to access instance methods of Type.
+  void test_undefinedMethod_static_conditionalAccess() {
+    // The conditional access operator '?.' can be used to access static
+    // methods.
     Source source = addSource('''
-class A {}
-f() => A?.toString();
+class A {
+  static void m() {}
+}
+f() { A?.m(); }
 ''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_undefinedOperator_index() {
     Source source = addSource(r'''
 class A {
   operator [](a) {}
@@ skipping 24 matching lines @@
     Source source = addSource(r'''
 import 'lib.dart' as x;
 main() {
   x.y = 0;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_undefinedSetter_static_conditionalAccess() {
+    // The conditional access operator '?.' can be used to access static
+    // fields.
+    Source source = addSource('''
+class A {
+  static var x;
+}
+f() { A?.x = 1; }
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_undefinedSuperMethod_field() {
     Source source = addSource(r'''
 class A {
   var m;
 }
 class B extends A {
   f() {
     super.m();
   }
 }''');
@@ skipping 366 matching lines @@
     reset();
   }
 
   void _check_wrongNumberOfParametersForOperator1(String name) {
     _check_wrongNumberOfParametersForOperator(name, "a");
   }
 
   CompilationUnit _getResolvedLibraryUnit(Source source) =>
       analysisContext.getResolvedCompilationUnit2(source, source);
 }