Infer fields/getters/setters types according to the new top-level inference rules.

pkg/analyzer/test/src/summary/resynthesize_common.dart

 // Copyright (c) 2015, 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 test.src.serialization.elements_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 4706 matching lines @@
 const vGenericClass = D;
 const vEnum = E;
 const vFunctionTypeAlias = F;
 ''');
     if (isStrongMode) {
       checkElementText(
           library,
           r'''
 typedef dynamic F(int a, String b);
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E a;
   static const E b;
   static const E c;
 }
 class C {
 }
 class D<T> {
 }
 const Type vDynamic =
         dynamic/*location: dynamic*/;
 const Type vNull =
         Null/*location: dart:core;Null*/;
 const Type vObject =
         Object/*location: dart:core;Object*/;
 const Type vClass =
         C/*location: test.dart;C*/;
 const Type vGenericClass =
         D/*location: test.dart;D*/;
 const Type vEnum =
         E/*location: test.dart;E*/;
 const Type vFunctionTypeAlias =
         F/*location: test.dart;F*/;
 ''');
     } else {
       checkElementText(
           library,
           r'''
 typedef dynamic F(int a, String b);
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E a;
   static const E b;
   static const E c;
 }
 class C {
 }
 class D<T> {
 }
 const dynamic vDynamic =
         dynamic/*location: dynamic*/;
@@ skipping 678 matching lines @@
 enum E {a, b, c}
 final vValue = E.a;
 final vValues = E.values;
 final vIndex = E.a.index;
 ''');
     if (isStrongMode) {
       checkElementText(
           library,
           r'''
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E a;
   static const E b;
   static const E c;
 }
 final E vValue;
 final List<E> vValues;
 final dynamic vIndex;
 ''');
     } else {
       checkElementText(
           library,
           r'''
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E a;
   static const E b;
   static const E c;
 }
 final dynamic vValue;
 final dynamic vValues;
 final dynamic vIndex;
 ''');
     }
   }
 
   test_constExpr_pushReference_enum_method() {
     var library = checkLibrary('''
 enum E {a}
 final vToString = E.a.toString();
 ''');
     if (isStrongMode) {
       checkElementText(
           library,
           r'''
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E a;
 }
 final String vToString;
 ''');
     } else {
       checkElementText(
           library,
           r'''
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E a;
 }
 final dynamic vToString;
 ''');
     }
   }
 
   test_constExpr_pushReference_field_simpleIdentifier() {
     var library = checkLibrary('''
 class C {
@@ skipping 1412 matching lines @@
  */
 enum E { v }''');
     if (isStrongMode) {
       checkElementText(
           library,
           r'''
 /**
  * Docs
  */
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v;
 }
 ''');
     } else {
       checkElementText(
           library,
           r'''
 /**
  * Docs
  */
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v;
 }
 ''');
     }
   }
 
   test_enum_value_documented() {
     var library = checkLibrary('''
 enum E {
   /**
    * Docs
    */
   v
 }''');
     if (isStrongMode) {
       checkElementText(
           library,
           r'''
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   /**
    * Docs
    */
   static const E v;
 }
 ''');
     } else {
       checkElementText(
           library,
           r'''
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   /**
    * Docs
    */
   static const E v;
 }
 ''');
     }
   }
 
   test_enum_values() {
     var library = checkLibrary('enum E { v1, v2 }');
     if (isStrongMode) {
       checkElementText(
           library,
           r'''
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v1;
   static const E v2;
 }
 ''');
     } else {
       checkElementText(
           library,
           r'''
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v1;
   static const E v2;
 }
 ''');
     }
   }
 
   test_enums() {
     var library = checkLibrary('enum E1 { v1 } enum E2 { v2 }');
     if (isStrongMode) {
       checkElementText(
           library,
           r'''
 enum E1 {
-  final int index;
-  static const List<E1> values;
+  synthetic final int index;
+  synthetic static const List<E1> values;
   static const E1 v1;
 }
 enum E2 {
-  final int index;
-  static const List<E2> values;
+  synthetic final int index;
+  synthetic static const List<E2> values;
   static const E2 v2;
 }
 ''');
     } else {
       checkElementText(
           library,
           r'''
 enum E1 {
-  final int index;
-  static const List<E1> values;
+  synthetic final int index;
+  synthetic static const List<E1> values;
   static const E1 v1;
 }
 enum E2 {
-  final int index;
-  static const List<E2> values;
+  synthetic final int index;
+  synthetic static const List<E2> values;
   static const E2 v2;
 }
 ''');
     }
   }
 
   test_error_extendsEnum() {
     var library = checkLibrary('''
 enum E {a, b, c}
 
@@ skipping 11 matching lines @@
   foo() {}
 }
 
 class D = Object with M, E;
 ''');
     if (isStrongMode) {
       checkElementText(
           library,
           r'''
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E a;
   static const E b;
   static const E c;
 }
 class M {
 }
 class A {
   dynamic foo() {}
 }
 class B implements M {
   dynamic foo() {}
 }
 class C extends Object with M {
   synthetic C();
   dynamic foo() {}
 }
 class alias D extends Object with M {
   synthetic D() = Object;
 }
 ''');
     } else {
       checkElementText(
           library,
           r'''
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E a;
   static const E b;
   static const E c;
 }
 class M {
 }
 class A {
   dynamic foo() {}
 }
 class B implements M {
@@ skipping 3884 matching lines @@
 
   test_metadata_enumDeclaration() {
     var library = checkLibrary('const a = null; @a enum E { v }');
     if (isStrongMode) {
       checkElementText(
           library,
           r'''
 @
         a/*location: test.dart;a?*/
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v;
 }
 const dynamic a = null;
 ''');
     } else {
       checkElementText(
           library,
           r'''
 @
         a/*location: test.dart;a?*/
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v;
 }
 const dynamic a = null;
 ''');
     }
   }
 
   test_metadata_exportDirective() {
     addLibrarySource('/foo.dart', '');
     var library = checkLibrary('@a export "foo.dart"; const a = null;');
@@ skipping 2092 matching lines @@
 
   test_type_reference_lib_to_lib() {
     var library =
         checkLibrary('class C {} enum E { v } typedef F(); C c; E e; F f;');
     if (isStrongMode) {
       checkElementText(
           library,
           r'''
 typedef dynamic F();
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v;
 }
 class C {
 }
 C c;
 E e;
 F f;
 ''');
     } else {
       checkElementText(
           library,
           r'''
 typedef dynamic F();
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v;
 }
 class C {
 }
 C c;
 E e;
 F f;
 ''');
     }
   }
 
   test_type_reference_lib_to_part() {
     addSource('/a.dart', 'part of l; class C {} enum E { v } typedef F();');
     var library = checkLibrary('library l; part "a.dart"; C c; E e; F f;');
     if (isStrongMode) {
       checkElementText(
           library,
           r'''
 library l;
 part 'a.dart';
 C c;
 E e;
 F f;
 --------------------
 unit: a.dart
 
 typedef dynamic F();
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v;
 }
 class C {
 }
 ''');
     } else {
       checkElementText(
           library,
           r'''
 library l;
 part 'a.dart';
 C c;
 E e;
 F f;
 --------------------
 unit: a.dart
 
 typedef dynamic F();
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v;
 }
 class C {
 }
 ''');
     }
   }
 
   test_type_reference_part_to_lib() {
     addSource('/a.dart', 'part of l; C c; E e; F f;');
     var library = checkLibrary(
         'library l; part "a.dart"; class C {} enum E { v } typedef F();');
     if (isStrongMode) {
       checkElementText(
           library,
           r'''
 library l;
 part 'a.dart';
 typedef dynamic F();
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v;
 }
 class C {
 }
 --------------------
 unit: a.dart
 
 C c;
 E e;
 F f;
 ''');
     } else {
       checkElementText(
           library,
           r'''
 library l;
 part 'a.dart';
 typedef dynamic F();
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v;
 }
 class C {
 }
 --------------------
 unit: a.dart
 
 C c;
 E e;
 F f;
@@ skipping 10 matching lines @@
           library,
           r'''
 library l;
 part 'a.dart';
 part 'b.dart';
 --------------------
 unit: a.dart
 
 typedef dynamic F();
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v;
 }
 class C {
 }
 --------------------
 unit: b.dart
 
 C c;
 E e;
 F f;
 ''');
     } else {
       checkElementText(
           library,
           r'''
 library l;
 part 'a.dart';
 part 'b.dart';
 --------------------
 unit: a.dart
 
 typedef dynamic F();
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v;
 }
 class C {
 }
 --------------------
 unit: b.dart
 
 C c;
 E e;
 F f;
 ''');
     }
   }
 
   test_type_reference_part_to_part() {
     addSource('/a.dart',
         'part of l; class C {} enum E { v } typedef F(); C c; E e; F f;');
     var library = checkLibrary('library l; part "a.dart";');
     if (isStrongMode) {
       checkElementText(
           library,
           r'''
 library l;
 part 'a.dart';
 --------------------
 unit: a.dart
 
 typedef dynamic F();
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v;
 }
 class C {
 }
 C c;
 E e;
 F f;
 ''');
     } else {
       checkElementText(
           library,
           r'''
 library l;
 part 'a.dart';
 --------------------
 unit: a.dart
 
 typedef dynamic F();
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v;
 }
 class C {
 }
 C c;
 E e;
 F f;
 ''');
     }
   }
@@ skipping 61 matching lines @@
     }
   }
 
   test_type_reference_to_enum() {
     var library = checkLibrary('enum E { v } E e;');
     if (isStrongMode) {
       checkElementText(
           library,
           r'''
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v;
 }
 E e;
 ''');
     } else {
       checkElementText(
           library,
           r'''
 enum E {
-  final int index;
-  static const List<E> values;
+  synthetic final int index;
+  synthetic static const List<E> values;
   static const E v;
 }
 E e;
 ''');
     }
   }
 
   test_type_reference_to_import() {
     addLibrarySource('/a.dart', 'class C {} enum E { v }; typedef F();');
     var library = checkLibrary('import "a.dart"; C c; E e; F f;');
@@ skipping 1510 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }