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

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

 // Copyright (c) 2017, 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.
 
 import 'dart:io';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 35 matching lines @@
     new File(_testPath).writeAsStringSync(newCode);
   }
 }
 
 /**
  * Write the given [library] elements into the canonical text presentation
  * taking into account the specified 'withX' options. Then compare the
  * actual text with the given [expected] one.
  */
 void checkElementText(LibraryElement library, String expected,
-    {bool withOffsets: false}) {
-  var writer = new _ElementWriter(withOffsets: withOffsets);
+    {bool withOffsets: false,
+    bool withSyntheticAccessors: false,
+    bool withSyntheticFields: false}) {
+  var writer = new _ElementWriter(
+      withOffsets: withOffsets,
+      withSyntheticAccessors: withSyntheticAccessors,
+      withSyntheticFields: withSyntheticFields);
   writer.writeLibraryElement(library);
 
   String actualText = writer.buffer.toString();
   actualText =
       actualText.split('\n').map((line) => line.trimRight()).join('\n');
 
   if (_testPath != null && actualText != expected) {
     if (_testCode == null) {
       _testCode = new File(_testPath).readAsStringSync();
       _testCodeLines = new LineInfo.fromContent(_testCode);
@@ skipping 42 matching lines @@
 
   expect(actualText, expected);
 }
 
 /**
  * Writes the canonical text presentation of elements.
  */
 class _ElementWriter {
   final bool withOffsets;
   final bool withConstElements;
+  final bool withSyntheticAccessors;
+  final bool withSyntheticFields;
   final StringBuffer buffer = new StringBuffer();
 
-  _ElementWriter({this.withOffsets: false, this.withConstElements: true});
+  _ElementWriter(
+      {this.withOffsets: false,
+      this.withConstElements: true,
+      this.withSyntheticAccessors,
+      this.withSyntheticFields: false});
 
   bool isDynamicType(DartType type) => type is DynamicTypeImpl;
 
-  bool isEnumElement(Element e) {
-    return e is ClassElement && e.isEnum;
+  bool isEnumField(Element e) {
+    Element enclosing = e.enclosingElement;
+    return enclosing is ClassElement && enclosing.isEnum;
   }
 
   void newLineIfNotEmpty() {
     if (buffer.isNotEmpty) {
       buffer.writeln();
     }
   }
 
   void writeBodyModifiers(ExecutableElement e) {
     if (e.isAsynchronous) {
@@ skipping 30 matching lines @@
         e.mixins.isNotEmpty) {
       buffer.write(' extends ');
       writeType(e.supertype);
     }
 
     writeList(' with ', '', e.mixins, ', ', writeType);
     writeList(' implements ', '', e.interfaces, ', ', writeType);
 
     buffer.writeln(' {');
 
-    e.fields.forEach(writeFieldElement);
+    e.fields.forEach(writePropertyInducingElement);
     e.accessors.forEach(writePropertyAccessorElement);
 
     if (e.isEnum) {
       expect(e.constructors, isEmpty);
     } else {
       expect(e.constructors, isNotEmpty);
     }
 
     if (e.constructors.length == 1 &&
         e.constructors[0].isSynthetic &&
@@ skipping 214 matching lines @@
     } else if (e is TypeName) {
       writeExpression(e.name);
       if (e.typeArguments != null) {
         writeList('<', '>', e.typeArguments.arguments, ', ', writeExpression);
       }
     } else {
       fail('Unsupported expression type: ${e.runtimeType}');
     }
   }
 
-  void writeFieldElement(FieldElement e) {
-    if (e.isSynthetic && !isEnumElement(e.enclosingElement)) {
-      return;
-    }
-
-    writeDocumentation(e, '  ');
-    writeMetadata(e, '  ', '\n');
-
-    buffer.write('  ');
-
-    writeIf(e.isStatic, 'static ');
-    writeIf(e is FieldElementImpl && e.isCovariant, 'covariant ');
-
-    writePropertyInducingElement(e);
-  }
-
   void writeFunctionElement(FunctionElement e) {
     writeIf(e.isExternal, 'external ');
 
     writeType2(e.returnType);
 
     writeName(e);
 
     writeTypeParameterElements(e.typeParameters);
     writeParameterElements(e.parameters);
 
@@ skipping 177 matching lines @@
   }
 
   void writePartElement(CompilationUnitElement e) {
     writeMetadata(e, '', '\n');
     buffer.write('part ');
     writeUri(e, e.source);
     buffer.writeln(';');
   }
 
   void writePropertyAccessorElement(PropertyAccessorElement e) {
-    if (e.isSynthetic) {
+    if (e.isSynthetic && !withSyntheticAccessors) {
       return;
     }
 
     if (e.enclosingElement is ClassElement) {
       writeDocumentation(e, '  ');
       writeMetadata(e, '  ', '\n');
 
       buffer.write('  ');
 
+      writeIf(e.isSynthetic, 'synthetic ');
       writeIf(e.isStatic, 'static ');
     } else {
       writeDocumentation(e);
       writeMetadata(e, '', '\n');
+      writeIf(e.isSynthetic, 'synthetic ');
     }
 
     writeIf(e.isExternal, 'external ');
 
     writeType2(e.returnType);
 
     if (e.isGetter) {
       buffer.write('get ');
     } else {
       buffer.write('set ');
@@ skipping 12 matching lines @@
     expect(e.isGenerator, isFalse);
 
     if (e.isAbstract) {
       buffer.writeln(';');
     } else {
       buffer.writeln(' {}');
     }
   }
 
   void writePropertyInducingElement(PropertyInducingElement e) {
+    if (e.isSynthetic && !withSyntheticFields && !isEnumField(e)) {
+      return;
+    }
+
     DartType type = e.type;
     expect(type, isNotNull);
 
+    if (e.enclosingElement is ClassElement) {
+      writeDocumentation(e, '  ');
+      writeMetadata(e, '  ', '\n');
+
+      buffer.write('  ');
+
+      writeIf(e.isSynthetic, 'synthetic ');
+      writeIf(e.isStatic, 'static ');
+      writeIf(e is FieldElementImpl && e.isCovariant, 'covariant ');
+    } else {
+      writeDocumentation(e);
+      writeMetadata(e, '', '\n');
+    }
+
     writeIf(e.isFinal, 'final ');
     writeIf(e.isConst, 'const ');
     writeType2(type);
 
     writeName(e);
 
     if (e is ConstVariableElement) {
       Expression initializer = (e as ConstVariableElement).constantInitializer;
       if (initializer != null) {
         buffer.write(' = ');
         writeExpression(initializer);
       }
     }
 
     // TODO(scheglov) Paul: One of the things that was hardest to get right
     // when resynthesizing the element model was the synthetic function for the
     // initializer.  Can we write that out (along with its return type)?
 
     buffer.writeln(';');
   }
 
-  void writeTopLevelVariableElement(TopLevelVariableElement e) {
-    if (e.isSynthetic) {
-      return;
-    }
-    writeDocumentation(e);
-    writeMetadata(e, '', '\n');
-    writePropertyInducingElement(e);
-  }
-
   void writeType(DartType type) {
     if (type is InterfaceType) {
       buffer.write(type.element.name);
       if (type.element.typeParameters.isNotEmpty) {
         writeList('<', '>', type.typeArguments, ', ', writeType);
       }
     } else {
       buffer.write(type.displayName);
     }
   }
@@ skipping 17 matching lines @@
 
   void writeUnitElement(CompilationUnitElement e) {
     if (e.library.definingCompilationUnit != e) {
       buffer.writeln('-' * 20);
       buffer.writeln('unit: ${e.source.shortName}');
       buffer.writeln();
     }
     e.functionTypeAliases.forEach(writeFunctionTypeAliasElement);
     e.enums.forEach(writeClassElement);
     e.types.forEach(writeClassElement);
-    e.topLevelVariables.forEach(writeTopLevelVariableElement);
+    e.topLevelVariables.forEach(writePropertyInducingElement);
     e.accessors.forEach(writePropertyAccessorElement);
     e.functions.forEach(writeFunctionElement);
   }
 
   void writeUri(UriReferencedElement e, Source source) {
     String uri = e.uri ?? source.uri.toString();
     buffer.write('\'$uri\'');
     if (withOffsets) {
       buffer.write('(');
       buffer.write('${e.uriOffset}, ');
@@ skipping 26 matching lines @@
     return components.join(';');
   }
 }
 
 class _Replacement {
   final int offset;
   final int end;
   final String text;
   _Replacement(this.offset, this.end, this.text);
 }