java2dart improvement - use field if getter/setter are trivial.

pkg/analyzer_experimental/test/generated/resolver_test.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.resolver_test;
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source_io.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
 import 'package:analyzer_experimental/src/generated/ast.dart';
 import 'package:analyzer_experimental/src/generated/parser.dart' show ParserErrorCode;
@@ skipping 5987 matching lines @@
         runJUnitTest(__test, __test.test_visitTypeName_void);
       });
     });
   }
 }
 class ResolverTestCase extends EngineTestCase {
 
   /**
    * The source factory used to create [Source].
    */
-  SourceFactory _sourceFactory;
+  SourceFactory sourceFactory;
 
   /**
    * The analysis context used to parse the compilation units being resolved.
    */
-  AnalysisContextImpl _analysisContext;
+  AnalysisContextImpl analysisContext;
   void setUp() {
     reset();
   }
 
   /**
    * Add a source file to the content provider.
    *
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the added file
    */
   Source addSource(String contents) => addSource2("/test.dart", contents);
 
   /**
    * Add a source file to the content provider. The file path should be absolute.
    *
    * @param filePath the path of the file being added
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the added file
    */
   Source addSource2(String filePath, String contents) {
     Source source = cacheSource(filePath, contents);
     ChangeSet changeSet = new ChangeSet();
     changeSet.added(source);
-    _analysisContext.applyChanges(changeSet);
+    analysisContext.applyChanges(changeSet);
     return source;
   }
 
   /**
    * Assert that the number of errors that have been gathered matches the number of errors that are
    * given and that they have the expected error codes. The order in which the errors were gathered
    * is ignored.
    *
    * @param expectedErrorCodes the error codes of the errors that should have been gathered
    * @throws AssertionFailedError if a different number of errors have been gathered than were
    *           expected
    */
   void assertErrors(List<ErrorCode> expectedErrorCodes) {
     GatheringErrorListener errorListener = new GatheringErrorListener();
-    for (ChangeNotice notice in _analysisContext.performAnalysisTask()) {
+    for (ChangeNotice notice in analysisContext.performAnalysisTask()) {
       for (AnalysisError error in notice.errors) {
         errorListener.onError(error);
       }
     }
     errorListener.assertErrors2(expectedErrorCodes);
   }
 
   /**
    * Assert that no errors have been gathered.
    *
    * @throws AssertionFailedError if any errors have been gathered
    */
   void assertNoErrors() {
     GatheringErrorListener errorListener = new GatheringErrorListener();
-    for (ChangeNotice notice in _analysisContext.performAnalysisTask()) {
+    for (ChangeNotice notice in analysisContext.performAnalysisTask()) {
       for (AnalysisError error in notice.errors) {
         errorListener.onError(error);
       }
     }
     errorListener.assertNoErrors();
   }
 
   /**
    * Cache the source file content in the source factory but don't add the source to the analysis
    * context. The file path should be absolute.
    *
    * @param filePath the path of the file being cached
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the cached file
    */
   Source cacheSource(String filePath, String contents) {
-    Source source = new FileBasedSource.con1(_sourceFactory.contentCache, FileUtilities2.createFile(filePath));
-    _sourceFactory.setContents(source, contents);
+    Source source = new FileBasedSource.con1(sourceFactory.contentCache, FileUtilities2.createFile(filePath));
+    sourceFactory.setContents(source, contents);
     return source;
   }
 
   /**
    * Create a library element that represents a library named `"test"` containing a single
    * empty compilation unit.
    *
    * @return the library element that was created
    */
   LibraryElementImpl createTestLibrary() => createTestLibrary2(new AnalysisContextImpl(), "test", []);
@@ skipping 18 matching lines @@
       sourcedCompilationUnits[i] = compilationUnit;
     }
     String fileName = "${libraryName}.dart";
     CompilationUnitElementImpl compilationUnit = new CompilationUnitElementImpl(fileName);
     compilationUnit.source = createSource2(fileName);
     LibraryElementImpl library = new LibraryElementImpl(context, ASTFactory.libraryIdentifier2([libraryName]));
     library.definingCompilationUnit = compilationUnit;
     library.parts = sourcedCompilationUnits;
     return library;
   }
-  AnalysisContext get analysisContext => _analysisContext;
-  SourceFactory get sourceFactory => _sourceFactory;
 
   /**
    * Return a type provider that can be used to test the results of resolution.
    *
    * @return a type provider
    */
   TypeProvider get typeProvider {
-    Source coreSource = _analysisContext.sourceFactory.forUri(DartSdk.DART_CORE);
-    LibraryElement coreElement = _analysisContext.getLibraryElement(coreSource);
+    Source coreSource = analysisContext.sourceFactory.forUri(DartSdk.DART_CORE);
+    LibraryElement coreElement = analysisContext.getLibraryElement(coreSource);
     return new TypeProviderImpl(coreElement);
   }
 
   /**
    * In the rare cases we want to group several tests into single "test_" method, so need a way to
    * reset test instance to reuse it.
    */
   void reset() {
-    _analysisContext = AnalysisContextFactory.contextWithCore();
-    _sourceFactory = _analysisContext.sourceFactory;
+    analysisContext = AnalysisContextFactory.contextWithCore();
+    sourceFactory = analysisContext.sourceFactory;
   }
 
   /**
    * Given a library and all of its parts, resolve the contents of the library and the contents of
    * the parts. This assumes that the sources for the library and its parts have already been added
    * to the content provider using the method [addSource].
    *
    * @param librarySource the source for the compilation unit that defines the library
    * @return the element representing the resolved library
    * @throws AnalysisException if the analysis could not be performed
    */
-  LibraryElement resolve(Source librarySource) => _analysisContext.computeLibraryElement(librarySource);
+  LibraryElement resolve(Source librarySource) => analysisContext.computeLibraryElement(librarySource);
 
   /**
    * Return the resolved compilation unit corresponding to the given source in the given library.
    *
    * @param source the source of the compilation unit to be returned
    * @param library the library in which the compilation unit is to be resolved
    * @return the resolved compilation unit
    * @throws Exception if the compilation unit could not be resolved
    */
-  CompilationUnit resolveCompilationUnit(Source source, LibraryElement library) => _analysisContext.resolveCompilationUnit(source, library);
+  CompilationUnit resolveCompilationUnit(Source source, LibraryElement library) => analysisContext.resolveCompilationUnit(source, library);
 
   /**
    * Verify that all of the identifiers in the compilation units associated with the given sources
    * have been resolved.
    *
    * @param resolvedElementMap a table mapping the AST nodes that have been resolved to the element
    *          to which they were resolved
    * @param sources the sources identifying the compilation units to be verified
    * @throws Exception if the contents of the compilation unit cannot be accessed
    */
   void verify(List<Source> sources) {
     ResolutionVerifier verifier = new ResolutionVerifier();
     for (Source source in sources) {
-      _analysisContext.parseCompilationUnit(source).accept(verifier);
+      analysisContext.parseCompilationUnit(source).accept(verifier);
     }
     verifier.assertResolved();
   }
 
   /**
    * Create a source object representing a file with the given name and give it an empty content.
    *
    * @param fileName the name of the file for which a source is to be created
    * @return the source that was created
    */
   FileBasedSource createSource2(String fileName) {
-    FileBasedSource source = new FileBasedSource.con1(_sourceFactory.contentCache, FileUtilities2.createFile(fileName));
-    _sourceFactory.setContents(source, "");
+    FileBasedSource source = new FileBasedSource.con1(sourceFactory.contentCache, FileUtilities2.createFile(fileName));
+    sourceFactory.setContents(source, "");
     return source;
   }
   static dartSuite() {
     _ut.group('ResolverTestCase', () {
     });
   }
 }
 class TypeProviderImplTest extends EngineTestCase {
   void test_creation() {
     InterfaceType objectType = classElement("Object", null, []).type;
@@ skipping 11476 matching lines @@
 //  ErrorResolverTest.dartSuite();
 //  HintCodeTest.dartSuite();
 //  NonHintCodeTest.dartSuite();
 //  NonErrorResolverTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
 //  StrictModeTest.dartSuite();
 //  TypePropagationTest.dartSuite();
 }