Respect the "allowErrors" parameter in _ResynthesizeAstTest.checkLibrary.

pkg/analyzer/test/src/summary/resynthesize_common.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 test.src.serialization.elements_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 3238 matching lines @@
     checkLibrary('f() {} g() {}');
   }
 
   test_generic_gClass_gMethodStatic() {
     prepareAnalysisContext(createOptions());
     checkLibrary('''
 class C<T, U> {
   static void m<V, W>(V v, W w) {
     void f<X, Y>(V v, W w, X x, Y y) {
     }
+    print(f);

[scheglov, 2016/11/22 19:13:24]

It might be cleaner to filter out "unused X" errors at the point where we check
them.

[Paul Berry, 2016/11/22 20:51:53]

Good point.  Done.

   }
 }
 ''');
   }
 
   test_getElement_constructor_named() {
     String text = 'class C { C.named(); }';
     Source source = addLibrarySource('/test.dart', text);
     ConstructorElement original = context
         .computeLibraryElement(source)
@@ skipping 189 matching lines @@
     addLibrarySource('/b.dart', 'library b; class D {}');
     checkLibrary('import "a.dart"; import "b.dart"; C c; D d;');
   }
 
   test_inferred_function_type_for_variable_in_generic_function() {
     // In the code below, `x` has an inferred type of `() => int`, with 2
     // (unused) type parameters from the enclosing top level function.
     checkLibrary('''
 f<U, V>() {
   var x = () => 0;
+  print(x);
 }
 ''');
   }
 
   test_inferred_function_type_in_generic_class_constructor() {
     // In the code below, `() => () => 0` has an inferred return type of
     // `() => int`, with 2 (unused) type parameters from the enclosing class.
     checkLibrary('''
 class C<U, V> {
   final x;
@@ skipping 145 matching lines @@
 
   test_initializer_executable_with_return_type_from_closure_field() {
     checkLibrary('''
 class C {
   var v = () => 0;
 }
 ''');
   }
 
   test_initializer_executable_with_return_type_from_closure_local() {
-    checkLibrary('''
+    checkLibrary(r'''
 void f() {
   int u = 0;
   var v = () => 0;
+  print('$u$v');
 }
 ''');
   }
 
   test_instantiateToBounds_boundRefersToEarlierTypeArgument() {
     checkLibrary('''
 class C<S extends num, T extends C<S, T>> {}
 C c;
 ''');
   }
@@ skipping 43 matching lines @@
   test_library_named() {
     checkLibrary('library foo.bar;');
   }
 
   test_localFunctions() {
     checkLibrary(r'''
 f() {
   f1() {}
   {
     f2() {}
+    print(f2);
   }
+  print(f1);
 }
 ''');
   }
 
   test_localFunctions_inConstructor() {
     checkLibrary(r'''
 class C {
   C() {
     f() {}
+    print(f);
   }
 }
 ''');
   }
 
   test_localFunctions_inMethod() {
     checkLibrary(r'''
 class C {
   m() {
     f() {}
+    print(f);
   }
 }
 ''');
   }
 
   test_localFunctions_inTopLevelGetter() {
     checkLibrary(r'''
 get g {
   f() {}
+  print(f);
 }
 ''');
   }
 
   test_localLabels_inConstructor() {
     checkLibrary(
         r'''
 class C {
   C() {
     aaa: while (true) {}
@@ skipping 35 matching lines @@
 }
 ''',
         allowErrors: true);
   }
 
   test_localVariables_inConstructor() {
     checkLibrary(r'''
 class C {
   C() {
     int v;
+    print(v);
     f() {}
+    print(f);
   }
 }
 ''');
   }
 
   test_localVariables_inLocalFunction() {
     checkLibrary(r'''
 f() {
   f1() {
     int v1 = 1;
+    print(v1);
   } // 2
+  print(f1);
   f2() {
     int v1 = 1;
+    print(v1);
     f3() {
       int v2 = 1;
+      print(v2);
     }
+    print(f3);
   }
+  print(f2);
 }
 ''');
   }
 
   test_localVariables_inMethod() {
     checkLibrary(r'''
 class C {
   m() {
     int v;
+    print(v);
   }
 }
 ''');
   }
 
   test_localVariables_inTopLevelFunction() {
     checkLibrary(r'''
 main() {
   int v1 = 1;
+  print(v1);
   {
     const String v2 = 'bbb';
+    print(v2);
   }
   Map<int, List<double>> v3;
+  print(v3);
 }
 ''');
   }
 
   test_localVariables_inTopLevelGetter() {
     checkLibrary(r'''
 get g {
   int v;
+  print(v);
 }
 ''');
   }
 
   test_main_class() {
     checkLibrary('class main {}');
   }
 
   test_main_class_alias() {
     checkLibrary('class main = C with D; class C {} class D {}');
@@ skipping 248 matching lines @@
     prepareAnalysisContext(createOptions());
     checkLibrary('class C { void f<T, U>(T x(U u)) {} }');
   }
 
   test_nested_generic_functions_in_generic_class_with_function_typed_params() {
     checkLibrary('''
 class C<T, U> {
   void g<V, W>() {
     void h<X, Y>(void p(T t, U u, V v, W w, X x, Y y)) {
     }
+    print(h);
   }
 }
 ''');
   }
 
   test_nested_generic_functions_in_generic_class_with_local_variables() {
-    checkLibrary('''
+    checkLibrary(r'''
 class C<T, U> {
   void g<V, W>() {
     void h<X, Y>() {
       T t;
       U u;
       V v;
       W w;
       X x;
       Y y;
+      print('$t$u$v$w$x$y');
     }
+    print(h);
   }
 }
 ''');
   }
 
   test_nested_generic_functions_with_function_typed_param() {
     checkLibrary('''
 void f<T, U>() {
   void g<V, W>() {
     void h<X, Y>(void p(T t, U u, V v, W w, X x, Y y)) {
     }
+    print(h);
   }
+  print(g);
 }
 ''');
   }
 
   test_nested_generic_functions_with_local_variables() {
-    checkLibrary('''
+    checkLibrary(r'''
 void f<T, U>() {
   void g<V, W>() {
     void h<X, Y>() {
       T t;
       U u;
       V v;
       W w;
       X x;
       Y y;
+      print('$t$u$v$w$x$y');
     }
+    print(h);
   }
+  print(g);
 }
 ''');
   }
 
   test_operator() {
     checkLibrary('class C { C operator+(C other) => null; }');
   }
 
   test_operator_equal() {
     checkLibrary('class C { bool operator==(Object other) => false; }');
@@ skipping 67 matching lines @@
     addSource('/a.dart', 'part of my.lib;');
     addSource('/b.dart', 'part of my.lib;');
     checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
   }
 
   test_propagated_type_refers_to_closure() {
     checkLibrary('''
 void f() {
   var x = () => 0;
   var y = x;
+  print(y);
 }
 ''');
   }
 
   test_setter_documented() {
     checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
@@ skipping 43 matching lines @@
       // method syntax doesn't support generic closures.  So it can only run in
       // strong mode.
       // TODO(paulberry): once proper generic method syntax supports generic
       // closures, rewrite the test below without using generic comment syntax,
       // and remove this hack.  See dartbug.com/25819
       return;
     }
     checkLibrary('''
 void f<T, U>(bool b) {
   final v = b ? /*<V>*/(T t, U u, V v) => 0 : /*<V>*/(T t, U u, V v) => 1;
+  print(v);
 }
 ''');
   }
 
   test_syntheticFunctionType_inGenericClass() {
     checkLibrary('''
 class C<T, U> {
   var v = f() ? (T t, U u) => 0 : (T t, U u) => 1;
 }
 bool f() => false;
 ''');
   }
 
   test_syntheticFunctionType_inGenericFunction() {
     checkLibrary('''
 void f<T, U>(bool b) {
   var v = b ? (T t, U u) => 0 : (T t, U u) => 1;
+  print(v);
 }
 ''');
   }
 
   test_syntheticFunctionType_noArguments() {
     checkLibrary('''
 final v = f() ? () => 0 : () => 1;
 bool f() => true;
 ''');
   }
@@ skipping 210 matching lines @@
 
   test_typedef_type_parameters_f_bound_simple() {
     checkLibrary('typedef U F<T extends U, U>(T t);');
   }
 
   test_typedefs() {
     checkLibrary('f() {} g() {}');
   }
 
   test_unresolved_annotation_namedConstructorCall_noClass() {
-    checkLibrary('@foo.bar() class C {}');
+    checkLibrary('@foo.bar() class C {}', allowErrors: true);
   }
 
   test_unresolved_annotation_namedConstructorCall_noConstructor() {
-    checkLibrary('@String.foo() class C {}');
+    checkLibrary('@String.foo() class C {}', allowErrors: true);
   }
 
   test_unresolved_annotation_prefixedIdentifier_badPrefix() {
-    checkLibrary('@foo.bar class C {}');
+    checkLibrary('@foo.bar class C {}', allowErrors: true);
   }
 
   test_unresolved_annotation_prefixedIdentifier_noDeclaration() {
-    checkLibrary('import "dart:async" as foo; @foo.bar class C {}');
+    checkLibrary('import "dart:async" as foo; @foo.bar class C {}',
+        allowErrors: true);
   }
 
   test_unresolved_annotation_prefixedNamedConstructorCall_badPrefix() {
-    checkLibrary('@foo.bar.baz() class C {}');
+    checkLibrary('@foo.bar.baz() class C {}', allowErrors: true);
   }
 
   test_unresolved_annotation_prefixedNamedConstructorCall_noClass() {
-    checkLibrary('import "dart:async" as foo; @foo.bar.baz() class C {}');
+    checkLibrary('import "dart:async" as foo; @foo.bar.baz() class C {}',
+        allowErrors: true);
   }
 
   test_unresolved_annotation_prefixedNamedConstructorCall_noConstructor() {
-    checkLibrary('import "dart:async" as foo; @foo.Future.bar() class C {}');
+    checkLibrary('import "dart:async" as foo; @foo.Future.bar() class C {}',
+        allowErrors: true);
   }
 
   test_unresolved_annotation_prefixedUnnamedConstructorCall_badPrefix() {
-    checkLibrary('@foo.bar() class C {}');
+    checkLibrary('@foo.bar() class C {}', allowErrors: true);
   }
 
   test_unresolved_annotation_prefixedUnnamedConstructorCall_noClass() {
-    checkLibrary('import "dart:async" as foo; @foo.bar() class C {}');
+    checkLibrary('import "dart:async" as foo; @foo.bar() class C {}',
+        allowErrors: true);
   }
 
   test_unresolved_annotation_simpleIdentifier() {
-    checkLibrary('@foo class C {}');
+    checkLibrary('@foo class C {}', allowErrors: true);
   }
 
   test_unresolved_annotation_unnamedConstructorCall_noClass() {
-    checkLibrary('@foo() class C {}');
+    checkLibrary('@foo() class C {}', allowErrors: true);
   }
 
   test_unresolved_export() {
     allowMissingFiles = true;
     checkLibrary("export 'foo.dart';", allowErrors: true);
   }
 
   test_unresolved_import() {
     allowMissingFiles = true;
     checkLibrary("import 'foo.dart';", allowErrors: true);
@@ skipping 153 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }