Generate unique names less aggressively.

pkg/analyzer_experimental/lib/src/generated/source_io.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.source.io;
 
 import 'source.dart';
 import 'dart:io';
 import 'dart:uri';
 import 'java_core.dart';
 import 'java_io.dart';
@@ skipping 34 matching lines @@
   }
   _jtd_constructor_328_impl(ContentCache contentCache, JavaFile file) {
     _jtd_constructor_329_impl(contentCache, file, false);
   }
   /**
    * Initialize a newly created source object.
    * @param contentCache the content cache used to access the contents of this source
    * @param file the file represented by this source
    * @param inSystemLibrary {@code true} if this source is in one of the system libraries
    */
-  FileBasedSource.con2(ContentCache contentCache2, JavaFile file3, bool inSystemLibrary2) {
-    _jtd_constructor_329_impl(contentCache2, file3, inSystemLibrary2);
+  FileBasedSource.con2(ContentCache contentCache2, JavaFile file2, bool inSystemLibrary2) {
+    _jtd_constructor_329_impl(contentCache2, file2, inSystemLibrary2);
   }
-  _jtd_constructor_329_impl(ContentCache contentCache2, JavaFile file3, bool inSystemLibrary2) {
+  _jtd_constructor_329_impl(ContentCache contentCache2, JavaFile file2, bool inSystemLibrary2) {
     this._contentCache = contentCache2;
-    this._file = file3;
+    this._file = file2;
     this._inSystemLibrary = inSystemLibrary2;
-    this._fileUriString = file3.toURI().toString();
+    this._fileUriString = file2.toURI().toString();
   }
   bool operator ==(Object object) => object != null && this.runtimeType == object.runtimeType && _file == ((object as FileBasedSource))._file;
   bool exists() => _contentCache.getContents(this) != null || (_file.exists() && !_file.isDirectory());
   void getContents(Source_ContentReceiver receiver) {
     {
       String contents = _contentCache.getContents(this);
       if (contents != null) {
         receiver.accept2(contents, _contentCache.getModificationStamp(this));
         return;
       }
@@ skipping 66 matching lines @@
   PackageUriResolver(List<JavaFile> packagesDirectories) {
     if (packagesDirectories.length < 1) {
       throw new IllegalArgumentException("At least one package directory must be provided");
     }
     this._packagesDirectories = packagesDirectories;
   }
   Source resolveAbsolute(ContentCache contentCache, Uri uri) {
     if (!isPackageUri(uri)) {
       return null;
     }
-    String path4 = uri.path;
-    if (path4 == null) {
-      path4 = uri.path;
-      if (path4 == null) {
+    String path2 = uri.path;
+    if (path2 == null) {
+      path2 = uri.path;
+      if (path2 == null) {
         return null;
       }
     }
     String pkgName;
     String relPath;
-    int index = path4.indexOf('/');
+    int index = path2.indexOf('/');
     if (index == -1) {
-      pkgName = path4;
+      pkgName = path2;
       relPath = "";
     } else if (index == 0) {
       return null;
     } else {
-      pkgName = path4.substring(0, index);
-      relPath = path4.substring(index + 1);
+      pkgName = path2.substring(0, index);
+      relPath = path2.substring(index + 1);
     }
     for (JavaFile packagesDirectory in _packagesDirectories) {
-      JavaFile resolvedFile = new JavaFile.relative(packagesDirectory, path4);
+      JavaFile resolvedFile = new JavaFile.relative(packagesDirectory, path2);
       if (resolvedFile.exists()) {
         return new FileBasedSource.con1(contentCache, getCanonicalFile(packagesDirectory, pkgName, relPath));
       }
     }
     return new FileBasedSource.con1(contentCache, getCanonicalFile(_packagesDirectories[0], pkgName, relPath));
   }
   /**
    * Answer the canonical file for the specified package.
    * @param packagesDirectory the "packages" directory (not {@code null})
    * @param pkgName the package name (not {@code null}, not empty)
@@ skipping 41 matching lines @@
   DirectoryBasedSourceContainer.con1(JavaFile directory) {
     _jtd_constructor_326_impl(directory);
   }
   _jtd_constructor_326_impl(JavaFile directory) {
     _jtd_constructor_327_impl(directory.getPath());
   }
   /**
    * Construct a container representing the specified path and containing any sources whose{@link Source#getFullName()} starts with the specified path.
    * @param path the path (not {@code null} and not empty)
    */
-  DirectoryBasedSourceContainer.con2(String path3) {
-    _jtd_constructor_327_impl(path3);
+  DirectoryBasedSourceContainer.con2(String path2) {
+    _jtd_constructor_327_impl(path2);
   }
-  _jtd_constructor_327_impl(String path3) {
-    this._path = appendFileSeparator(path3);
+  _jtd_constructor_327_impl(String path2) {
+    this._path = appendFileSeparator(path2);
   }
   bool contains(Source source) => source.fullName.startsWith(_path);
   bool operator ==(Object obj) => (obj is DirectoryBasedSourceContainer) && ((obj as DirectoryBasedSourceContainer)).path == path;
   /**
    * Answer the receiver's path, used to determine if a source is contained in the receiver.
    * @return the path (not {@code null}, not empty)
    */
   String get path => _path;
   int get hashCode => _path.hashCode;
 }
@@ skipping 18 matching lines @@
    */
   FileUriResolver() : super() {
   }
   Source resolveAbsolute(ContentCache contentCache, Uri uri) {
     if (!isFileUri(uri)) {
       return null;
     }
     return new FileBasedSource.con1(contentCache, new JavaFile.fromUri(uri));
   }
 }