New analyzer snapshot.

pkg/analyzer/lib/src/generated/sdk_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.sdk.io;
+
 import 'java_core.dart';
 import 'java_io.dart';
 import 'java_engine_io.dart';
 import 'source_io.dart';
 import 'error.dart';
 import 'scanner.dart';
 import 'ast.dart';
 import 'parser.dart';
 import 'sdk.dart';
 import 'engine.dart';
+
 /**
  * Instances of the class `DirectoryBasedDartSdk` represent a Dart SDK installed in a
  * specified directory.
  *
  * @coverage dart.engine.sdk
  */
 class DirectoryBasedDartSdk implements DartSdk {
-
   /**
    * The [AnalysisContext] which is used for all of the sources in this [DartSdk].
    */
   InternalAnalysisContext _analysisContext;
 
   /**
    * The directory containing the SDK.
    */
   JavaFile directory;
 
@@ skipping 190 matching lines @@
     initializeLibraryMap();
     _analysisContext = new AnalysisContextImpl();
     _analysisContext.sourceFactory = new SourceFactory.con2([new DartUriResolver(this)]);
     List<String> uris = this.uris;
     ChangeSet changeSet = new ChangeSet();
     for (String uri in uris) {
       changeSet.added(_analysisContext.sourceFactory.forUri(uri));
     }
     _analysisContext.applyChanges(changeSet);
   }
+
   Source fromEncoding(ContentCache contentCache, UriKind kind, Uri uri) => new FileBasedSource.con2(contentCache, new JavaFile.fromUri(uri), kind);
+
   AnalysisContext get context => _analysisContext;
 
   /**
    * Return the file containing the Dartium executable, or `null` if it does not exist.
    *
    * @return the file containing the Dartium executable
    */
   JavaFile get dartiumExecutable {
     {
       if (_dartiumExecutable == null) {
@@ skipping 52 matching lines @@
   /**
    * Return the file containing the Pub executable, or `null` if it does not exist.
    *
    * @return the file containing the Pub executable
    */
   JavaFile get pubExecutable {
     String pubBinaryName = OSUtilities.isWindows() ? _PUB_EXECUTABLE_NAME_WIN : _PUB_EXECUTABLE_NAME;
     JavaFile file = new JavaFile.relative(new JavaFile.relative(directory, _BIN_DIRECTORY_NAME), pubBinaryName);
     return file.exists() ? file : null;
   }
+
   List<SdkLibrary> get sdkLibraries => _libraryMap.sdkLibraries;
+
   SdkLibrary getSdkLibrary(String dartUri) => _libraryMap.getLibrary(dartUri);
 
   /**
    * Return the revision number of this SDK, or `"0"` if the revision number cannot be
    * discovered.
    *
    * @return the revision number of this SDK
    */
   String get sdkVersion {
     {
@@ skipping 42 matching lines @@
    * @return `true` if this installation of the SDK has documentation
    */
   bool hasDocumentation() => docDirectory.exists();
 
   /**
    * Return `true` if the Dartium binary is available.
    *
    * @return `true` if the Dartium binary is available
    */
   bool get isDartiumInstalled => dartiumExecutable != null;
+
   Source mapDartUri(String dartUri) {
     SdkLibrary library = getSdkLibrary(dartUri);
     if (library == null) {
       return null;
     }
     return new FileBasedSource.con2(_analysisContext.sourceFactory.contentCache, new JavaFile.relative(libraryDirectory, library.path), UriKind.DART_URI);
   }
 
   /**
    * Ensure that the dart VM is executable. If it is not, make it executable and log that it was
@@ skipping 46 matching lines @@
 
   /**
    * Initialize the state of the SDK.
    */
   void initializeSdk() {
     if (!OSUtilities.isWindows()) {
       ensureVmIsExecutable();
     }
   }
 }
+
 /**
  * Instances of the class `SdkLibrariesReader` read and parse the libraries file
  * (dart-sdk/lib/_internal/libraries.dart) for information about the libraries in an SDK. The
  * library information is represented as a Dart file containing a single top-level variable whose
  * value is a const map. The keys of the map are the names of libraries defined in the SDK and the
  * values in the map are info objects defining the library. For example, a subset of a typical SDK
  * might have a libraries file that looks like the following:
  *
  * <pre>
  * final Map&lt;String, LibraryInfo&gt; LIBRARIES = const &lt;LibraryInfo&gt; {
  *   // Used by VM applications
  *   "builtin" : const LibraryInfo(
  *     "builtin/builtin_runtime.dart",
  *     category: "Server",
  *     platforms: VM_PLATFORM),
  *
  *   "compiler" : const LibraryInfo(
  *     "compiler/compiler.dart",
  *     category: "Tools",
  *     platforms: 0),
  * };
  * </pre>
  *
  * @coverage dart.engine.sdk
  */
 class SdkLibrariesReader {
-
   /**
    * Return the library map read from the given source.
    *
    * @return the library map read from the given source
    */
   LibraryMap readFrom(JavaFile librariesFile, String libraryFileContents) {
     List<bool> foundError = [false];
-    AnalysisErrorListener errorListener = new AnalysisErrorListener_10(foundError);
+    AnalysisErrorListener errorListener = new AnalysisErrorListener_11(foundError);
     Source source = new FileBasedSource.con2(null, librariesFile, UriKind.FILE_URI);
     Scanner scanner = new Scanner(source, new CharSequenceReader(new CharSequence(libraryFileContents)), errorListener);
     Parser parser = new Parser(source, errorListener);
     CompilationUnit unit = parser.parseCompilationUnit(scanner.tokenize());
     SdkLibrariesReader_LibraryBuilder libraryBuilder = new SdkLibrariesReader_LibraryBuilder();
     if (!foundError[0]) {
       unit.accept(libraryBuilder);
     }
     return libraryBuilder.librariesMap;
   }
 }
+
 class SdkLibrariesReader_LibraryBuilder extends RecursiveASTVisitor<Object> {
-
   /**
    * The prefix added to the name of a library to form the URI used in code to reference the
    * library.
    */
   static String _LIBRARY_PREFIX = "dart:";
 
   /**
    * The name of the optional parameter used to indicate whether the library is an implementation
    * library.
    */
@@ skipping 19 matching lines @@
    * The value of the [PLATFORMS] parameter used to specify that the library can
    * be used on the VM.
    */
   static String _VM_PLATFORM = "VM_PLATFORM";
 
   /**
    * The library map that is populated by visiting the AST structure parsed from the contents of
    * the libraries file.
    */
   final LibraryMap librariesMap = new LibraryMap();
+
   Object visitMapLiteralEntry(MapLiteralEntry node) {
     String libraryName = null;
     Expression key = node.key;
     if (key is SimpleStringLiteral) {
-      libraryName = "${_LIBRARY_PREFIX}${((key as SimpleStringLiteral)).value}";
+      libraryName = "${_LIBRARY_PREFIX}${(key as SimpleStringLiteral).value}";
     }
     Expression value = node.value;
     if (value is InstanceCreationExpression) {
       SdkLibraryImpl library = new SdkLibraryImpl(libraryName);
-      List<Expression> arguments = ((value as InstanceCreationExpression)).argumentList.arguments;
+      List<Expression> arguments = (value as InstanceCreationExpression).argumentList.arguments;
       for (Expression argument in arguments) {
         if (argument is SimpleStringLiteral) {
-          library.path = ((argument as SimpleStringLiteral)).value;
+          library.path = (argument as SimpleStringLiteral).value;
         } else if (argument is NamedExpression) {
-          String name = ((argument as NamedExpression)).name.label.name;
-          Expression expression = ((argument as NamedExpression)).expression;
+          String name = (argument as NamedExpression).name.label.name;
+          Expression expression = (argument as NamedExpression).expression;
           if (name == _CATEGORY) {
-            library.category = ((expression as SimpleStringLiteral)).value;
+            library.category = (expression as SimpleStringLiteral).value;
           } else if (name == _IMPLEMENTATION) {
-            library.implementation = ((expression as BooleanLiteral)).value;
+            library.implementation = (expression as BooleanLiteral).value;
           } else if (name == _DOCUMENTED) {
-            library.documented = ((expression as BooleanLiteral)).value;
+            library.documented = (expression as BooleanLiteral).value;
           } else if (name == _PLATFORMS) {
             if (expression is SimpleIdentifier) {
-              String identifier = ((expression as SimpleIdentifier)).name;
+              String identifier = (expression as SimpleIdentifier).name;
               if (identifier == _VM_PLATFORM) {
                 library.setVmLibrary();
               } else {
                 library.setDart2JsLibrary();
               }
             }
           }
         }
       }
       librariesMap.setLibrary(libraryName, library);
     }
     return null;
   }
 }
-class AnalysisErrorListener_10 implements AnalysisErrorListener {
+
+class AnalysisErrorListener_11 implements AnalysisErrorListener {
   List<bool> foundError;
-  AnalysisErrorListener_10(this.foundError);
+
+  AnalysisErrorListener_11(this.foundError);
+
   void onError(AnalysisError error) {
-    foundError[0] = true;
+    if (error != null && error.errorCode.type != ErrorType.TODO) {
+      foundError[0] = true;
+    }
   }
 }