switch package to strong mode

lib/src/resolver_impl.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_transformer.src.resolver_impl;
 
 import 'dart:async';
 import 'package:analyzer/analyzer.dart' show parseDirectives;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart'
@@ skipping 13 matching lines @@
 
 // We should always be using url paths here since it's always Dart/pub code.
 final path = native_path.url;
 
 /// Resolves and updates an AST based on Barback-based assets.
 ///
 /// This also provides a handful of useful APIs for traversing and working
 /// with the resolved AST.
 class ResolverImpl implements Resolver {
   /// Cache of all asset sources currently referenced.
-  final Map<AssetId, _AssetBasedSource> sources;
+  final Map<AssetId, AssetBasedSource> sources;
 
   final InternalAnalysisContext _context =
       AnalysisEngine.instance.createAnalysisContext();
 
   /// Transform for which this is currently updating, or null when not updating.
   Transform _currentTransform;
 
   /// The currently resolved entry libraries, or null if nothing is resolved.
   List<LibraryElement> _entryLibraries;
   Set<LibraryElement> _libraries;
 
   /// Future indicating when this resolver is done in the current phase.
   Future _lastPhaseComplete = new Future.value();
 
   /// Completer for wrapping up the current phase.
   Completer _currentPhaseComplete;
 
   /// Creates a resolver with a given [sdk] implementation for resolving
   /// `dart:*` imports.
   ResolverImpl(DartSdk sdk, DartUriResolver dartUriResolver,
-      {AnalysisOptions options, Map<AssetId, _AssetBasedSource> sources})
-      : sources = sources ?? <AssetId, _AssetBasedSource>{} {
+      {AnalysisOptions options, Map<AssetId, AssetBasedSource> sources})
+      : sources = sources ?? <AssetId, AssetBasedSource>{} {
     if (options == null) {
       options = new AnalysisOptionsImpl()
         ..cacheSize = 256 // # of sources to cache ASTs for.
         ..preserveComments = false
         ..analyzeFunctionBodies = true;
     }
     _context.analysisOptions = options;
     sdk.context.analysisOptions = options;
     _context.sourceFactory =
         new SourceFactory([dartUriResolver, new _AssetUriResolver(this)]);
@@ skipping 47 matching lines @@
     var visited = new Set<AssetId>();
     var visiting = new FutureGroup();
     var toUpdate = [];
 
     void processAsset(AssetId assetId) {
       visited.add(assetId);
 
       visiting.add(transform.readInputAsString(assetId).then((contents) {
         var source = sources[assetId];
         if (source == null) {
-          source = new _AssetBasedSource(assetId, this);
+          source = new AssetBasedSource(assetId, this);
           sources[assetId] = source;
         }
         source.updateDependencies(contents);
         toUpdate.add(new _PendingUpdate(source, contents));
         source.dependentAssets
             .where((id) => !visited.contains(id))
             .forEach(processAsset);
       }, onError: (e) {
         var source = sources[assetId];
         if (source != null && source.exists()) {
@@ skipping 115 matching lines @@
         .evaluate(expression);
   }
 
   Uri getImportUri(LibraryElement lib, {AssetId from}) =>
       _getSourceUri(lib, from: from);
 
   /// Similar to getImportUri but will get the part URI for parts rather than
   /// the library URI.
   Uri _getSourceUri(Element element, {AssetId from}) {
     var source = element.source;
-    if (source is _AssetBasedSource) {
+    if (source is AssetBasedSource) {
       var uriString = assetIdToUri(source.assetId, from: from);
       return uriString != null ? Uri.parse(uriString) : null;
     } else if (source is UriAnnotatedSource) {
       return source.uri;
     }
     // Should not be able to encounter any other source types.
     throw new StateError('Unable to resolve URI for ${source.runtimeType}');
   }
 
   AssetId getSourceAssetId(Element element) {
     var source = element.source;
-    if (source is _AssetBasedSource) return source.assetId;
+    if (source is AssetBasedSource) return source.assetId;
     return null;
   }
 
   SourceSpan getSourceSpan(Element element) {
     var sourceFile = getSourceFile(element);
     if (sourceFile == null) return null;
     return sourceFile.span(
         element.computeNode().offset, element.computeNode().end);
   }
 
   TextEditTransaction createTextEditTransaction(Element element) {
-    if (element.source is! _AssetBasedSource) return null;
+    if (element.source is! AssetBasedSource) return null;
 
     // Cannot edit unless there is an active transformer.
     if (_currentTransform == null) return null;
 
-    _AssetBasedSource source = element.source;
+    AssetBasedSource source = element.source;
     // Cannot modify assets in other packages.
     if (source.assetId.package != _currentTransform.primaryInput.id.package) {
       return null;
     }
 
     var sourceFile = getSourceFile(element);
     if (sourceFile == null) return null;
 
     return new TextEditTransaction(source.rawContents, sourceFile);
   }
 
   /// Gets the SourceFile for the source of the element.
   SourceFile getSourceFile(Element element) {
     var assetId = getSourceAssetId(element);
     if (assetId == null) return null;
 
     var importUri = _getSourceUri(element);
     var spanPath = importUri != null ? importUri.toString() : assetId.path;
     return new SourceFile(sources[assetId].rawContents, url: spanPath);
   }
 }
 
 /// Implementation of Analyzer's Source for Barback based assets.
-class _AssetBasedSource extends Source {
+class AssetBasedSource extends Source {
   /// Asset ID where this source can be found.
   final AssetId assetId;
 
   /// The resolver this is being used in.
   final ResolverImpl _resolver;
 
   /// Cache of dependent asset IDs, to avoid re-parsing the AST.
   Iterable<AssetId> _dependentAssets;
 
   /// The current revision of the file, incremented only when file changes.
   int _revision = 0;
 
   /// The file contents.
   String _contents;
 
-  _AssetBasedSource(this.assetId, this._resolver);
+  AssetBasedSource(this.assetId, this._resolver);
 
   /// Update the dependencies of this source. This parses [contents] but avoids
   /// any analyzer resolution.
   void updateDependencies(String contents) {
     if (contents == _contents) return;
     var unit = parseDirectives(contents, suppressErrors: true);
     _dependentAssets = unit.directives
-        .where((d) => (d is ImportDirective ||
-            d is PartDirective ||
-            d is ExportDirective))
-        .map((d) => _resolve(
-            assetId, d.uri.stringValue, _logger, _getSpan(d, contents)))
+        .where((d) => d is UriBasedDirective)
+        .map((d) => _resolve(assetId, (d as UriBasedDirective).uri.stringValue,
+            _logger, _getSpan(d, contents)))
         .where((id) => id != null)
         .toSet();
   }
 
   /// Update the contents of this file with [contents].
   ///
   /// Returns true if the contents of this asset have changed.
   bool updateContents(String contents) {
     if (contents == _contents) return false;
     _contents = contents;
@@ skipping 17 matching lines @@
   ///
   /// Only valid while the resolver is updating assets.
   TransformLogger get _logger => _resolver._currentTransform.logger;
 
   /// Gets all imports/parts/exports which resolve to assets (non-Dart files).
   Iterable<AssetId> get dependentAssets => _dependentAssets;
 
   bool exists() => _contents != null;
 
   bool operator ==(Object other) =>
-      other is _AssetBasedSource && assetId == other.assetId;
+      other is AssetBasedSource && assetId == other.assetId;
 
   int get hashCode => assetId.hashCode;
 
   void getContentsToReceiver(Source_ContentReceiver receiver) {
     receiver.accept(rawContents, modificationStamp);
   }
 
   String get encoding =>
       "${uriKind.encoding}${assetId.package}/${assetId.path}";
 
@@ skipping 61 matching lines @@
       assetId = _resolve(null, uri.toString(), logger, null);
       if (assetId == null) {
         logger.error('Unable to resolve asset ID for "$uri"');
         return null;
       }
     }
     var source = _resolver.sources[assetId];
     // Analyzer expects that sources which are referenced but do not exist yet
     // still exist, so just make an empty source.
     if (source == null) {
-      source = new _AssetBasedSource(assetId, _resolver);
+      source = new AssetBasedSource(assetId, _resolver);
       _resolver.sources[assetId] = source;
     }
     return source;
   }
 
   Source fromEncoding(UriKind kind, Uri uri) =>
       throw new UnsupportedError('fromEncoding is not supported');
 
   Uri restoreAbsolute(Source source) =>
       throw new UnsupportedError('restoreAbsolute is not supported');
@@ skipping 80 matching lines @@
    * error will be sent to the Future.
    */
   Future<List<E>> get future => _completer.future;
 }
 
 /// A pending update to notify the resolver that a [Source] has been added or
 /// changed. This is used by the `_performResolve` algorithm above to apply all
 /// changes after it first discovers the transitive closure of files that are
 /// reachable from the sources.
 class _PendingUpdate {
-  _AssetBasedSource source;
+  AssetBasedSource source;
   String content;
 
   _PendingUpdate(this.source, this.content);
 
   void apply(ChangeSet changeSet) {
     if (!source.updateContents(content)) return;
     if (source._revision == 1 && source._contents != null) {
       changeSet.addedSource(source);
     } else {
       changeSet.changedSource(source);
     }
   }
 }