Replace isAppropriateFor with suitabilityFor and start using it

pkg/analyzer/lib/src/task/driver.dart

 // Copyright (c) 2015, 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 analyzer.src.task.driver;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/context/cache.dart';
@@ skipping 136 matching lines @@
         if (workOrder != null) {
           return workOrder;
         }
       }
     }
   }
 
   /**
    * Create a work order that will produce the given [result] for the given
    * [target]. Return the work order that was created, or `null` if the result
-   * has already been computed.
+   * has either already been computed or cannot be computed.
    */
   WorkOrder createWorkOrderForResult(
       AnalysisTarget target, ResultDescriptor result) {
     CacheEntry entry = context.getCacheEntry(target);
     CacheState state = entry.getState(result);
     if (state == CacheState.VALID ||
         state == CacheState.ERROR ||
         state == CacheState.IN_PROCESS) {
       return null;
     }
     TaskDescriptor taskDescriptor = taskManager.findTask(target, result);
+    if (taskDescriptor == null) {
+      return null;
+    }
     try {
       WorkItem workItem =
           new WorkItem(context, target, taskDescriptor, result, 0, null);
       return new WorkOrder(taskManager, workItem);
     } catch (exception, stackTrace) {
       throw new AnalysisException(
           'Could not create work order (target = $target; taskDescriptor = $taskDescriptor; result = $result)',
           new CaughtException(exception, stackTrace));
     }
   }
@@ skipping 523 matching lines @@
         //
         throw new UnimplementedError();
       } else if (inputState != CacheState.VALID) {
         if (context.aboutToComputeResult(inputEntry, inputResult)) {
           inputState = CacheState.VALID;
           builder.currentValue = inputEntry.getValue(inputResult);
         } else {
           try {
             TaskDescriptor descriptor =
                 taskManager.findTask(inputTarget, inputResult);
+            if (descriptor == null) {
+              throw new AnalysisException(
+                  'Cannot find task to build $inputResult for $inputTarget');
+            }
             return new WorkItem(context, inputTarget, descriptor, inputResult,
                 level + 1, workOrder);
           } on AnalysisException catch (exception, stackTrace) {
             this.exception = new CaughtException(exception, stackTrace);
             return null;
+          } catch (exception, stackTrace) {
+            this.exception = new CaughtException(
+                throw new AnalysisException(
+                    'Cannot create work order to build $inputResult for $inputTarget',
+                    exception),
+                stackTrace);
+            return null;
           }
         }
       } else {
         builder.currentValue = inputEntry.getValue(inputResult);
         if (builder.flushOnAccess) {
           inputEntry.setState(inputResult, CacheState.FLUSHED);
         }
       }
       if (!builder.moveNext()) {
         inputs = builder.inputValue;
@@ skipping 87 matching lines @@
   final TaskManager taskManager;
 
   _WorkOrderDependencyWalker(this.taskManager, WorkItem startingNode)
       : super(startingNode);
 
   @override
   WorkItem getNextInput(WorkItem node, List<WorkItem> skipInputs) {
     return node.gatherInputs(taskManager, skipInputs);
   }
 }