Reformat

pkg/analyzer/lib/src/generated/source_io.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.
 
 // 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 'dart:collection';
@@ skipping 123 matching lines @@
    */
   FileBasedSource.con1(JavaFile file) : this.con2(file.toURI(), file);
 
   /**
    * Initialize a newly created source object.
    *
    * @param file the file represented by this source
    * @param uri the URI from which this source was originally derived
    */
   FileBasedSource.con2(Uri uri, JavaFile file)
-      : uri = uri, file = file,
+      : uri = uri,
+        file = file,
         id = _idTable.putIfAbsent(
-          '$uri@${file.getPath()}',
-          () => _idTable.length);
+            '$uri@${file.getPath()}', () => _idTable.length);
 
   @override
   TimestampedData<String> get contents {
     return PerformanceStatistics.io.makeCurrentWhile(() {
       return contentsFromFile;
     });
   }
 
   /**
    * Get the contents and timestamp of the underlying file.
    *
    * Clients should consider using the the method [AnalysisContext.getContents]
    * because contexts can have local overrides of the content of a source that the source is not
    * aware of.
    *
    * @return the contents of the source paired with the modification stamp of the source
    * @throws Exception if the contents of this source could not be accessed
    * See [contents].
    */
   TimestampedData<String> get contentsFromFile {
     return new TimestampedData<String>(
-        file.lastModified(),
-        fileReadMode(file.readAsStringSync()));
+        file.lastModified(), fileReadMode(file.readAsStringSync()));
   }
 
   @override
   String get encoding {
     if (_encoding == null) {
       _encoding = uri.toString();
     }
     return _encoding;
   }
 
@@ skipping 45 matching lines @@
       if (isOpaque) {
         String scheme = uri.scheme;
         String part = uri.path;
         if (scheme == DartUriResolver.DART_SCHEME && part.indexOf('/') < 0) {
           part = "$part/$part.dart";
         }
         baseUri = parseUriWithException("$scheme:/$part");
       }
       Uri result = baseUri.resolveUri(containedUri);
       if (isOpaque) {
-        result =
-            parseUriWithException("${result.scheme}:${result.path.substring(1)}");
+        result = parseUriWithException(
+            "${result.scheme}:${result.path.substring(1)}");
       }
       return result;
     } catch (exception, stackTrace) {
       throw new AnalysisException(
           "Could not resolve URI ($containedUri) relative to source ($uri)",
           new CaughtException(exception, stackTrace));
     }
   }
 
   @override
@@ skipping 129 matching lines @@
 
   /**
    * Answer the canonical file for the specified package.
    *
    * @param packagesDirectory the "packages" directory (not `null`)
    * @param pkgName the package name (not `null`, not empty)
    * @param relPath the path relative to the package directory (not `null`, no leading slash,
    *          but may be empty string)
    * @return the file (not `null`)
    */
-  JavaFile getCanonicalFile(JavaFile packagesDirectory, String pkgName,
-      String relPath) {
+  JavaFile getCanonicalFile(
+      JavaFile packagesDirectory, String pkgName, String relPath) {
     JavaFile pkgDir = new JavaFile.relative(packagesDirectory, pkgName);
     try {
       pkgDir = pkgDir.getCanonicalFile();
     } on JavaIOException catch (exception, stackTrace) {
       if (!exception.toString().contains("Required key not available")) {
-        AnalysisEngine.instance.logger.logError(
-            "Canonical failed: $pkgDir",
+        AnalysisEngine.instance.logger.logError("Canonical failed: $pkgDir",
             new CaughtException(exception, stackTrace));
       } else if (_CanLogRequiredKeyIoException) {
         _CanLogRequiredKeyIoException = false;
-        AnalysisEngine.instance.logger.logError(
-            "Canonical failed: $pkgDir",
+        AnalysisEngine.instance.logger.logError("Canonical failed: $pkgDir",
             new CaughtException(exception, stackTrace));
       }
     }
-    return new JavaFile.relative(
-        pkgDir,
-        relPath.replaceAll('/', new String.fromCharCode(JavaFile.separatorChar)));
+    return new JavaFile.relative(pkgDir, relPath.replaceAll(
+        '/', new String.fromCharCode(JavaFile.separatorChar)));
   }
 
   @override
   Source resolveAbsolute(Uri uri) {
     if (!isPackageUri(uri)) {
       return null;
     }
     String path = uri.path;
     if (path == null) {
       path = uri.path;
@@ skipping 21 matching lines @@
       if (resolvedFile.exists()) {
         JavaFile canonicalFile =
             getCanonicalFile(packagesDirectory, pkgName, relPath);
         if (_isSelfReference(packagesDirectory, canonicalFile)) {
           uri = canonicalFile.toURI();
         }
         return new FileBasedSource.con2(uri, canonicalFile);
       }
     }
     return new FileBasedSource.con2(
-        uri,
-        getCanonicalFile(_packagesDirectories[0], pkgName, relPath));
+        uri, getCanonicalFile(_packagesDirectories[0], pkgName, relPath));
   }
 
   @override
   Uri restoreAbsolute(Source source) {
     String sourcePath = source.fullName;
     for (JavaFile packagesDirectory in _packagesDirectories) {
       List<JavaFile> pkgFolders = packagesDirectory.listFiles();
       if (pkgFolders != null) {
         for (JavaFile pkgFolder in pkgFolders) {
           try {
             String pkgCanonicalPath = pkgFolder.getCanonicalPath();
             if (sourcePath.startsWith(pkgCanonicalPath)) {
               String relPath = sourcePath.substring(pkgCanonicalPath.length);
               return parseUriWithException(
                   "$PACKAGE_SCHEME:${pkgFolder.getName()}$relPath");
             }
-          } catch (e) {
-          }
+          } catch (e) {}
         }
       }
     }
     return null;
   }
 
   /**
    * @return `true` if "file" was found in "packagesDir", and it is part of the "lib" folder
    *         of the application that contains in this "packagesDir".
    */
@@ skipping 59 matching lines @@
   }
 
   /**
    * Return `true` if the given URI is a `file` URI.
    *
    * @param uri the URI being tested
    * @return `true` if the given URI is a `file` URI
    */
   static bool isFileUri(Uri uri) => uri.scheme == FILE_SCHEME;
 }