Explicitly compute analysis results for sources to check errors.

pkg/analyzer/test/generated/strong_mode_test.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.
 
 library analyzer.test.generated.strong_mode_test;
 
 import 'dart:async';
+
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
@@ skipping 660 matching lines @@
   }
 
   test_inference_hints() async {
     Source source = addSource(r'''
       void main () {
         var x = 3;
         List<int> l0 = [];
      }
    ''');
     resolve2(source);
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_inferredFieldDeclaration_propagation() async {
     // Regression test for https://github.com/dart-lang/sdk/issues/25546
     String code = r'''
       abstract class A {
         Map<int, List<int>> get map;
       }
       class B extends A {
@@ skipping 622 matching lines @@
 ''');
     expectIdentifierType('methodTearOffInst', "(int) → int");
     expectIdentifierType('staticTearOffInst', "(int) → int");
     expectIdentifierType('staticFieldTearOffInst', "(int) → int");
     expectIdentifierType('topFunTearOffInst', "(int) → int");
     expectIdentifierType('topFieldTearOffInst', "(int) → int");
     expectIdentifierType('localTearOffInst', "(int) → int");
     expectIdentifierType('paramTearOffInst', "(int) → int");
   }
 
-  Future<Null> _objectMethodOnFunctions_helper2(String code) async {
-    await resolveTestUnit(code);
-    expectIdentifierType('t0', "String");
-    expectIdentifierType('t1', "() → String");
-    expectIdentifierType('t2', "int");
-    expectIdentifierType('t3', "String");
-    expectIdentifierType('t4', "() → String");
-    expectIdentifierType('t5', "int");
-  }
-
   void setUp() {
     super.setUp();
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.strongMode = true;
     resetWithOptions(options);
   }
 
   test_dynamicObjectGetter_hashCode() async {
     String code = r'''
 main() {
@@ skipping 456 matching lines @@
   }
 
   test_genericMethod_override_invalidReturnType() async {
     Source source = addSource(r'''
 class C {
   Iterable/*<T>*/ f/*<T>*/(/*=T*/ x) => null;
 }
 class D extends C {
   String f/*<S>*/(/*=S*/ x) => null;
 }''');
-    await assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+    await computeAnalysisResult(source);
+    assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
     verify([source]);
   }
 
   test_genericMethod_override_invalidTypeParamBounds() async {
     Source source = addSource(r'''
 class A {}
 class B extends A {}
 class C {
   /*=T*/ f/*<T extends A>*/(/*=T*/ x) => null;
 }
 class D extends C {
   /*=T*/ f/*<T extends B>*/(/*=T*/ x) => null;
 }''');
-    await assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+    await computeAnalysisResult(source);
+    assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
     verify([source]);
   }
 
   test_genericMethod_override_invalidTypeParamCount() async {
     Source source = addSource(r'''
 class C {
   /*=T*/ f/*<T>*/(/*=T*/ x) => null;
 }
 class D extends C {
   /*=S*/ f/*<T, S>*/(/*=T*/ x) => null;
 }''');
-    await assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+    await computeAnalysisResult(source);
+    assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
     verify([source]);
   }
 
   test_genericMethod_propagatedType_promotion() async {
     // Regression test for:
     // https://github.com/dart-lang/sdk/issues/25340
 
     // Note, after https://github.com/dart-lang/sdk/issues/25486 the original
     // example won't work, as we now compute a static type and therefore discard
     // the propagated type. So a new test was created that doesn't run under
@@ skipping 220 matching lines @@
     await _objectMethodOnFunctions_helper2(code);
   }
 
   test_setterWithDynamicTypeIsError() async {
     Source source = addSource(r'''
 class A {
   dynamic set f(String s) => null;
 }
 dynamic set g(int x) => null;
 ''');
-    await assertErrors(source, [
+    await computeAnalysisResult(source);
+    assertErrors(source, [
       StaticWarningCode.NON_VOID_RETURN_FOR_SETTER,
       StaticWarningCode.NON_VOID_RETURN_FOR_SETTER
     ]);
     verify([source]);
   }
 
   test_setterWithExplicitVoidType_returningVoid() async {
     Source source = addSource(r'''
 void returnsVoid() {}
 class A {
   void set f(String s) => returnsVoid();
 }
 void set g(int x) => returnsVoid();
 ''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_setterWithNoVoidType() async {
     Source source = addSource(r'''
 class A {
   set f(String s) {
     return '42';
   }
 }
 set g(int x) => 42;
 ''');
-    await assertErrors(source, [
+    await computeAnalysisResult(source);
+    assertErrors(source, [
       StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
     ]);
     verify([source]);
   }
 
   test_setterWithNoVoidType_returningVoid() async {
     Source source = addSource(r'''
 void returnsVoid() {}
 class A {
   set f(String s) => returnsVoid();
 }
 set g(int x) => returnsVoid();
 ''');
-    await assertNoErrors(source);
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
     verify([source]);
   }
 
   test_setterWithOtherTypeIsError() async {
     Source source = addSource(r'''
 class A {
   String set f(String s) => null;
 }
 Object set g(x) => null;
 ''');
-    await assertErrors(source, [
+    await computeAnalysisResult(source);
+    assertErrors(source, [
       StaticWarningCode.NON_VOID_RETURN_FOR_SETTER,
       StaticWarningCode.NON_VOID_RETURN_FOR_SETTER
     ]);
     verify([source]);
   }
 
   test_ternaryOperator_null_left() async {
     String code = r'''
 main() {
   var foo = (true) ? null : 3;
 }
 ''';
     await resolveTestUnit(code);
     expectInitializerType('foo', 'int', isNull);
   }
 
   test_ternaryOperator_null_right() async {
     String code = r'''
 main() {
   var foo = (true) ? 3 : null;
 }
 ''';
     await resolveTestUnit(code);
     expectInitializerType('foo', 'int', isNull);
   }
+
+  Future<Null> _objectMethodOnFunctions_helper2(String code) async {
+    await resolveTestUnit(code);
+    expectIdentifierType('t0', "String");
+    expectIdentifierType('t1', "() → String");
+    expectIdentifierType('t2', "int");
+    expectIdentifierType('t3', "String");
+    expectIdentifierType('t4', "() → String");
+    expectIdentifierType('t5', "int");
+  }
 }
 
 @reflectiveTest
 class StrongModeTypePropagationTest extends ResolverTestCase {
   @override
   void setUp() {
     super.setUp();
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.strongMode = true;
     resetWithOptions(options);
@@ skipping 229 matching lines @@
 main() {
   var v = x;
   v; // marker
 }
 int x = 3;
 ''';
     await assertPropagatedAssignedType(code, typeProvider.intType, null);
     await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 }