New analzyer snapshot.

pkg/analyzer/test/generated/test_support.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.test_support;
 
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_junit.dart';
+import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/ast.dart' show AstNode, NodeLocator;
 import 'package:analyzer/src/generated/element.dart' show InterfaceType, MethodElement, PropertyAccessorElement;
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:unittest/unittest.dart' as _ut;
 
 /**
  * Instances of the class `GatheringErrorListener` implement an error listener that collects
@@ skipping 588 matching lines @@
   }
 
   /**
    * Assert that the given object is an instance of the expected class.
    *
    * @param expectedClass the class that the object is expected to be an instance of
    * @param object the object being tested
    * @return the object that was being tested
    * @throws Exception if the object is not an instance of the expected class
    */
-  static Object assertInstanceOf(Type expectedClass, Object object) {
-    if (!isInstanceOf(object, expectedClass)) {
+  static Object assertInstanceOf(Predicate<Object> predicate, Type expectedClass, Object object) {
+    if (!predicate(object)) {
       JUnitTestCase.fail("Expected instance of ${expectedClass.toString()}, found ${(object == null ? "null" : object.runtimeType.toString())}");
     }
     return object;
   }
 
   /**
    * Assert that the given array is non-`null` and has the expected number of elements.
    *
    * @param expectedLength the expected number of elements
    * @param array the array being tested
@@ skipping 12 matching lines @@
    * Assert that the actual token has the same type and lexeme as the expected token. Note that this
    * does not assert anything about the offsets of the tokens (although the lengths will be equal).
    *
    * @param expectedToken the token that was expected
    * @param actualToken the token that was found
    * @throws AssertionFailedError if the two tokens are not the same
    */
   static void assertMatches(Token expectedToken, Token actualToken) {
     JUnitTestCase.assertEquals(expectedToken.type, actualToken.type);
     if (expectedToken is KeywordToken) {
-      assertInstanceOf(KeywordToken, actualToken);
+      assertInstanceOf((obj) => obj is KeywordToken, KeywordToken, actualToken);
       JUnitTestCase.assertEquals(expectedToken.keyword, (actualToken as KeywordToken).keyword);
     } else if (expectedToken is StringToken) {
-      assertInstanceOf(StringToken, actualToken);
+      assertInstanceOf((obj) => obj is StringToken, StringToken, actualToken);
       JUnitTestCase.assertEquals(expectedToken.lexeme, (actualToken as StringToken).lexeme);
     }
   }
 
   /**
    * Assert that the given list is non-`null` and has the expected number of elements.
    *
    * @param expectedSize the expected number of elements
    * @param list the list being tested
    * @throws AssertionFailedError if the list is `null` or does not have the expected number
@@ skipping 49 matching lines @@
     PrintStringWriter writer = new PrintStringWriter();
     for (String line in lines) {
       writer.println(line);
     }
     return writer.toString();
   }
 
   /**
    * @return the [AstNode] with requested type at offset of the "prefix".
    */
-  static AstNode findNode(AstNode root, String code, String prefix, Type clazz) {
+  static AstNode findNode(AstNode root, String code, String prefix, Predicate<AstNode> predicate) {
     int offset = code.indexOf(prefix);
     if (offset == -1) {
       throw new IllegalArgumentException("Not found '${prefix}'.");
     }
     AstNode node = new NodeLocator.con1(offset).searchWithin(root);
-    return node.getAncestor(clazz);
+    return node.getAncestor(predicate);
   }
 
   static void assertContains2(List<Object> array, List<bool> found, Object element) {
     if (element == null) {
       for (int i = 0; i < array.length; i++) {
         if (!found[i]) {
           if (array[i] == null) {
             found[i] = true;
             return;
           }
@@ skipping 145 matching lines @@
         return trampoline(target, arguments[0], arguments[1]);
       case 3:
         return trampoline(target, arguments[0], arguments[1], arguments[2]);
       case 4:
         return trampoline(target, arguments[0], arguments[1], arguments[2], arguments[3]);
       default:
         throw new IllegalArgumentException("Not implemented for > 4 arguments");
     }
   }
 }