Update charted to 0.4.8 and roll

packages/code_transformers/lib/src/dart_sdk.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.
 
 library code_transformers.src.dart_sdk;
 
 import 'dart:io' show Directory;
 
+import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/src/context/context.dart';
+import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart';
-import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/sdk.dart';
-import 'package:analyzer/src/generated/sdk_io.dart' show DirectoryBasedDartSdk;
 import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/summary/idl.dart';
 import 'package:cli_util/cli_util.dart' as cli_util;
 
 /// Attempts to provide the current Dart SDK directory.
 ///
 /// This will return null if the SDK cannot be found
 ///
 /// Note that this may not be correct when executing outside of `pub`.
 String get dartSdkDirectory {
   Directory sdkDir = cli_util.getSdkDir();
   return sdkDir != null ? sdkDir.path : null;
 }
 
 /// Sources that are annotated with a source uri, so it is easy to resolve how
 /// to support `Resolver.getImportUri`.
 abstract class UriAnnotatedSource extends Source {
   Uri get uri;
 }
 
 /// Dart SDK which wraps all Dart sources as [UriAnnotatedSource] to ensure they
 /// are tracked with Uris.
-class DirectoryBasedDartSdkProxy extends DirectoryBasedDartSdk {
-  DirectoryBasedDartSdkProxy(String sdkDirectory)
-      : super(new JavaFile(sdkDirectory));
+class FolderBasedDartSdkProxy extends FolderBasedDartSdk {
+  FolderBasedDartSdkProxy(
+      ResourceProvider resourceProvider, String sdkDirectory)
+      : super(resourceProvider, resourceProvider.getFolder(sdkDirectory));
 
   Source mapDartUri(String dartUri) =>
       DartSourceProxy.wrap(super.mapDartUri(dartUri), Uri.parse(dartUri));
 }
 
 /// Dart SDK resolver which wraps all Dart sources to ensure they are tracked
 /// with URIs.
 class DartUriResolverProxy implements DartUriResolver {
   final DartUriResolver _proxy;
   DartUriResolverProxy(DartSdk sdk) : _proxy = new DartUriResolver(sdk);
 
   Source resolveAbsolute(Uri uri, [Uri actualUri]) =>
       DartSourceProxy.wrap(_proxy.resolveAbsolute(uri, actualUri), uri);
 
   DartSdk get dartSdk => _proxy.dartSdk;
 
   Source fromEncoding(UriKind kind, Uri uri) =>
       throw new UnsupportedError('fromEncoding is not supported');
 
   Uri restoreAbsolute(Source source) =>
       throw new UnsupportedError('restoreAbsolute is not supported');
 }
 
 /// Source file for dart: sources which track the sources with dart: URIs.
 ///
 /// This is primarily to support [Resolver.getImportUri] for Dart SDK (dart:)
 /// based libraries.
 class DartSourceProxy implements UriAnnotatedSource {
-
   /// Absolute URI which this source can be imported from
   final Uri uri;
 
   /// Underlying source object.
   final Source _proxy;
 
   Source get source => this;
 
   DartSourceProxy(this._proxy, this.uri);
 
@@ skipping 25 matching lines @@
       (other is DartSourceProxy && _proxy == other._proxy);
 
   int get hashCode => _proxy.hashCode;
 
   TimestampedData<String> get contents => _proxy.contents;
 
   String get encoding => _proxy.encoding;
 
   String get fullName => _proxy.fullName;
 
+  Source get librarySource => _proxy.librarySource;
+
   int get modificationStamp => _proxy.modificationStamp;
 
   String get shortName => _proxy.shortName;
 
   UriKind get uriKind => _proxy.uriKind;
 
   bool get isInSystemLibrary => _proxy.isInSystemLibrary;
 }
 
 /// Dart SDK which contains a mock implementation of the SDK libraries. May be
 /// used to speed up resultion when most of the core libraries is not needed.
 class MockDartSdk implements DartSdk {
   final Map<Uri, _MockSdkSource> _sources = {};
   final bool reportMissing;
   final Map<String, SdkLibrary> _libs = {};
   final String sdkVersion = '0';
   List<String> get uris => _sources.keys.map((uri) => '$uri').toList();
-  final AnalysisContext context = new SdkAnalysisContext();
+  final InternalAnalysisContext context;
   DartUriResolver _resolver;
   DartUriResolver get resolver => _resolver;
 
-  MockDartSdk(Map<String, String> sources, {this.reportMissing}) {
+  MockDartSdk(Map<String, String> sources, AnalysisOptions options,
+      {this.reportMissing})
+      : this.context = new SdkAnalysisContext(options) {
     sources.forEach((uriString, contents) {
       var uri = Uri.parse(uriString);
       _sources[uri] = new _MockSdkSource(uri, contents);
       _libs[uriString] = new SdkLibraryImpl(uri.path)
         ..setDart2JsLibrary()
         ..setVmLibrary();
     });
     _resolver = new DartUriResolver(this);
     context.sourceFactory = new SourceFactory([_resolver]);
   }
@@ skipping 16 matching lines @@
       _sources[uri] =
           src = new _MockSdkSource(uri, 'library dart.${uri.path};');
     }
     return src;
   }
 
   @override
   Source fromFileUri(Uri uri) {
     throw new UnsupportedError('MockDartSdk.fromFileUri');
   }
+
+  @override
+  PackageBundle getLinkedBundle() => null;
 }
 
 class _MockSdkSource implements UriAnnotatedSource {
   /// Absolute URI which this source can be imported from.
   final Uri uri;
   final String _contents;
 
   Source get source => this;
 
+  Source get librarySource => null;
+
   _MockSdkSource(this.uri, this._contents);
 
   bool exists() => true;
 
   int get hashCode => uri.hashCode;
 
   final int modificationStamp = 1;
 
   TimestampedData<String> get contents =>
       new TimestampedData(modificationStamp, _contents);
 
   String get encoding => "${uriKind.encoding}$uri";
 
   String get fullName => shortName;
 
   String get shortName => uri.path;
 
   UriKind get uriKind => UriKind.DART_URI;
 
   bool get isInSystemLibrary => true;
 
   Source resolveRelative(Uri relativeUri) =>
       throw new UnsupportedError('not expecting relative urls in dart: mocks');
 
   Uri resolveRelativeUri(Uri relativeUri) =>
       throw new UnsupportedError('not expecting relative urls in dart: mocks');
+
+  bool operator ==(Object other) => identical(this, other);
 }
 
 /// Sample mock SDK sources.
 final Map<String, String> mockSdkSources = {
   // The list of types below is derived from types that are used internally by
   // the resolver (see _initializeFrom in analyzer/src/generated/resolver.dart).
   'dart:core': '''
         library dart.core;
 
         void print(Object o) {}
@@ skipping 28 matching lines @@
         class _Proxy { const _Proxy(); }
         const Object proxy = const _Proxy();
 
         class Iterable<E> {}
         class List<E> implements Iterable<E> {}
         class Map<K, V> {}
         ''',
   'dart:async': '''
         class Future<T> {
           Future then(callback) {}
+        }
+        class FutureOr<T> {}
         class Stream<T> {}
   ''',
   'dart:html': '''
         library dart.html;
         class HtmlElement {}
         ''',
 };