Fix error detection for a non-existent global script.

lib/src/barback/dependency_computer.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 pub.barback.dependency_computer;
 
 import 'package:barback/barback.dart';
 import 'package:path/path.dart' as p;
 
 import '../dart.dart';
@@ skipping 25 matching lines @@
 
   /// A cache of the results of [transformersNeededByPackage].
   final _transformersNeededByPackages = new Map<String, Set<TransformerId>>();
 
   /// The set of all packages that neither use transformers themselves nor
   /// import packages that use transformers.
   ///
   /// This is precomputed before any package computers are loaded.
   final _untransformedPackages = new Set<String>();
 
+  /// Creates a dependency computer for [graph].
+  ///
+  /// If [rootDevDependencies] is true, this includes the root package's dev
+  /// dependencies in the computation.
   DependencyComputer(this._graph) {
     for (var package in ordered(_graph.packages.keys)) {
       if (_graph.transitiveDependencies(package).every((dependency) =>
             dependency.pubspec.transformers.isEmpty)) {
         _untransformedPackages.add(package);
       }
     }
 
     ordered(_graph.packages.keys).forEach(_loadPackageComputer);
   }
@@ skipping 122 matching lines @@
           }
 
           if (_loadingPackageComputers.contains(id.package)) {
             throw new CycleException("$packageName is transformed by $id");
           }
 
           results.add(id);
         }
       }
 
-      var dependencies = packageName == _graph.entrypoint.root.name ?
-          package.immediateDependencies : package.dependencies;
+      var dependencies =
+          !_graph.entrypoint.isGlobal &&
+                  packageName == _graph.entrypoint.root.name
+              ? package.immediateDependencies
+              : package.dependencies;
       for (var dep in dependencies) {
         try {
           traversePackage(dep.name);
         } on CycleException catch (error) {
           throw error.prependStep("$packageName depends on ${dep.name}");
         }
       }
     }
 
     traversePackage(rootPackage);
@@ skipping 128 matching lines @@
   /// [DependencyComputer._transformersNeededByPackage]).
   Set<TransformerId> transformersNeededByLibrary(String library) {
     library = p.normalize(library);
     if (_activeLibraries.contains(library)) return new Set();
     _activeLibraries.add(library);
 
     try {
       var externalDirectives = _getTransitiveExternalDirectives(library);
       if (externalDirectives == null) {
         var rootName = _dependencyComputer._graph.entrypoint.root.name;
-        var dependencies = _package.name == rootName ?
-            _package.immediateDependencies : _package.dependencies;
+        var dependencies =
+            !_dependencyComputer._graph.entrypoint.isGlobal &&
+                    _package.name == rootName
+                ? _package.immediateDependencies
+                : _package.dependencies;
 
         // If anything transitively imported/exported by [library] within this
         // package is modified by a transformer, we don't know what it will
         // load, so we take the conservative approach and say it depends on
         // everything.
         return _applicableTransformers.map((config) => config.id).toSet().union(
             unionAll(dependencies.map((dep) {
           try {
             return _dependencyComputer._transformersNeededByPackage(dep.name);
           } on CycleException catch (error) {
@@ skipping 94 matching lines @@
       return null;
     }
 
     _directives[libraryUri] =
         parseImportsAndExports(readTextFile(library), name: library)
         .map((directive) => Uri.parse(directive.uri.stringValue))
         .toSet();
     return _directives[libraryUri];
   }
 }