Throw _LinkException when linking failed.

pkg/analyzer/lib/src/summary/pub_summary.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:core' hide Resource;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 170 matching lines @@
           CompilationUnit partUnit = _parse(partSource, strong);
           assembler.addUnlinkedUnit(partSource, serializeAstUnlinked(partUnit));
         }
       }
       // Add the SDK and the unlinked extension bundle.
       PackageBundleBuilder unlinkedBuilder = assembler.assemble();
       SummaryDataStore store = new SummaryDataStore(const <String>[]);
       store.addBundle(null, sdkBundle);
       store.addBundle(null, unlinkedBuilder);
       // Link the extension bundle.
-      bool failed = false;
-      Map<String, LinkedLibraryBuilder> linkedLibraries =
-          link([libUriStr].toSet(), (String absoluteUri) {
-        LinkedLibrary dependencyLibrary = store.linkedMap[absoluteUri];
-        if (dependencyLibrary == null) {
-          failed = true;
-        }
-        return dependencyLibrary;
-      }, (String absoluteUri) {
-        UnlinkedUnit unlinkedUnit = store.unlinkedMap[absoluteUri];
-        if (unlinkedUnit == null) {
-          failed = true;
-        }
-        return unlinkedUnit;
-      }, strong);
-      if (failed || linkedLibraries.length != 1) {
+      Map<String, LinkedLibraryBuilder> linkedLibraries;
+      try {
+        linkedLibraries = link([libUriStr].toSet(), (String absoluteUri) {
+          LinkedLibrary dependencyLibrary = store.linkedMap[absoluteUri];
+          if (dependencyLibrary == null) {
+            throw new _LinkException();
+          }
+          return dependencyLibrary;
+        }, (String absoluteUri) {
+          UnlinkedUnit unlinkedUnit = store.unlinkedMap[absoluteUri];
+          if (unlinkedUnit == null) {
+            throw new _LinkException();
+          }
+          return unlinkedUnit;
+        }, strong);
+      } on _LinkException {
+        return null;
+      }
+      if (linkedLibraries.length != 1) {
         return null;
       }
       // Append linked libraries into the assembler.
       linkedLibraries.forEach((uri, library) {
         assembler.addLinkedLibrary(uri, library);
       });
       List<int> bytes = assembler.assemble().toBuffer();
       return new PackageBundle.fromBuffer(bytes);
     } on FileSystemException {
       return null;
@@ skipping 37 matching lines @@
       PackageBundle extension = computeSdkExtension(context, sdkBundle);
       if (extension != null) {
         store.addBundle(null, extension);
       }
     }
     for (PackageBundle unlinked in unlinkedBundles.values) {
       store.addBundle(null, unlinked);
     }
 
     // Link each package node.
+//    Stopwatch linkTimer = new Stopwatch()..start();
     for (_LinkedNode node in nodes) {
       if (!node.isEvaluated) {
-        bool strong = context.analysisOptions.strongMode;
-        new _LinkedWalker(store, strong).walk(node);
+        try {
+          bool strong = context.analysisOptions.strongMode;
+          new _LinkedWalker(store, strong).walk(node);
+        } on _LinkException {
+          // Linking of the node failed.
+        }
       }
     }
+    // TODO(scheglov) remove debug output after optimizing
+//    print('LINKED ${unlinkedBundles.length} bundles'
+//        ' in ${linkTimer.elapsedMilliseconds} ms');
 
     // Create successfully linked packages.
     List<LinkedPubPackage> linkedPackages = <LinkedPubPackage>[];
     for (_LinkedNode node in nodes) {
       if (node.linkedBuilder != null) {
         List<int> bytes = node.linkedBuilder.toBuffer();
         PackageBundle linkedBundle = new PackageBundle.fromBuffer(bytes);
         linkedPackages.add(
             new LinkedPubPackage(node.package, node.unlinked, linkedBundle));
       }
@@ skipping 135 matching lines @@
       return bundle;
     }
     // Try to read from the file system.
     String fileName = _getUnlinkedName(strong);
     File unlinkedFile = package.folder.getChildAssumingFile(fileName);
     if (unlinkedFile.exists) {
       try {
         List<int> bytes = unlinkedFile.readAsBytesSync();
         bundle = new PackageBundle.fromBuffer(bytes);
         unlinkedBundleMap[package] = bundle;
+        // TODO(scheglov) if not in the pub cache, check for consistency
         return bundle;
       } on FileSystemException {
         // Ignore file system exceptions.
       }
     }
     // Schedule computation in the background, if in the pub cache.
     if (isPathInPubCache(pathContext, package.folder.path)) {
       if (seenPackages.add(package)) {
         if (packagesToComputeUnlinked.isEmpty) {
           _scheduleNextUnlinked();
@@ skipping 88 matching lines @@
   PackageBundleBuilder linkedBuilder;
   bool failed = false;
 
   _LinkedNode(this.package, this.unlinked, this.packageToNode);
 
   @override
   bool get isEvaluated => linkedBuilder != null || failed;
 
   @override
   List<_LinkedNode> computeDependencies() {
+    if (failed) {
+      return const <_LinkedNode>[];
+    }
+
     Set<_LinkedNode> dependencies = new Set<_LinkedNode>();
 
     void appendDependency(String uriStr) {
       Uri uri = FastUri.parse(uriStr);
       if (!uri.hasScheme) {
         // A relative path in this package, skip it.
       } else if (uri.scheme == 'dart') {
         // Dependency on the SDK is implicit and always added.
         // The SDK linked bundle is precomputed before linking packages.
       } else if (uriStr.startsWith('package:')) {
         String package = PubSummaryManager.getPackageName(uriStr);
         _LinkedNode packageNode = packageToNode[package];
         if (packageNode == null) {
           failed = true;
+          throw new _LinkException();
         }
         dependencies.add(packageNode);
       } else {
         failed = true;
+        throw new _LinkException();
       }
     }
 
     for (UnlinkedUnit unit in unlinked.unlinkedUnits) {
       for (UnlinkedImport import in unit.imports) {
         if (!import.isImplicit) {
           appendDependency(import.uri);
         }
       }
       for (UnlinkedExportPublic export in unit.publicNamespace.exports) {
         appendDependency(export.uri);
       }
     }
 
-    if (failed) {
-      return const <_LinkedNode>[];
-    }
     return dependencies.toList();
   }
 
   @override
   String toString() => package.toString();
 }
 
 /**
  * Specialization of [DependencyWalker] for linking packages.
  */
@@ skipping 11 matching lines @@
   @override
   void evaluateScc(List<_LinkedNode> scc) {
     Map<String, _LinkedNode> uriToNode = <String, _LinkedNode>{};
     for (_LinkedNode node in scc) {
       for (String uri in node.unlinked.unlinkedUnitUris) {
         uriToNode[uri] = node;
       }
     }
     Set<String> libraryUris = uriToNode.keys.toSet();
     // Perform linking.
-    bool failed = false;
     Map<String, LinkedLibraryBuilder> linkedLibraries =
         link(libraryUris, (String absoluteUri) {
       LinkedLibrary dependencyLibrary = store.linkedMap[absoluteUri];
       if (dependencyLibrary == null) {
-        failed = true;
+        scc.forEach((node) => node.failed = true);
+        throw new _LinkException();
       }
       return dependencyLibrary;
     }, (String absoluteUri) {
       UnlinkedUnit unlinkedUnit = store.unlinkedMap[absoluteUri];
       if (unlinkedUnit == null) {
-        failed = true;
+        scc.forEach((node) => node.failed = true);
+        throw new _LinkException();
       }
       return unlinkedUnit;
     }, strong);
     // Assemble linked bundles and put them into the store.
-    if (!failed) {
-      for (_LinkedNode node in scc) {
-        PackageBundleAssembler assembler = new PackageBundleAssembler();
-        linkedLibraries.forEach((uri, linkedLibrary) {
-          if (identical(uriToNode[uri], node)) {
-            assembler.addLinkedLibrary(uri, linkedLibrary);
-          }
-        });
-        node.linkedBuilder = assembler.assemble();
-        store.addBundle(null, node.linkedBuilder);
-      }
-    } else {
-      scc.forEach((node) => node.failed = true);
+    for (_LinkedNode node in scc) {
+      PackageBundleAssembler assembler = new PackageBundleAssembler();
+      linkedLibraries.forEach((uri, linkedLibrary) {
+        if (identical(uriToNode[uri], node)) {
+          assembler.addLinkedLibrary(uri, linkedLibrary);
+        }
+      });
+      node.linkedBuilder = assembler.assemble();
+      store.addBundle(null, node.linkedBuilder);
     }
   }
 }
+
+/**
+ * This exception is thrown during linking as a signal that linking of the
+ * current bundle cannot be performed, e.g. when a dependency cannot be found.
+ */
+class _LinkException {}