Serialize / resynthesize 'isAsynchronous' and 'isGenerator' flags.

pkg/analyzer/test/src/summary/summary_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 analyzer.test.src.summary.summary_common;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
@@ skipping 3124 matching lines @@
     _assertUnlinkedConst(variable.constExpr,
         operators: [UnlinkedConstOperation.pushTrue]);
   }
 
   test_constructor() {
     String text = 'class C { C(); }';
     UnlinkedExecutable executable =
         findExecutable('', executables: serializeClassText(text).executables);
     expect(executable.kind, UnlinkedExecutableKind.constructor);
     expect(executable.returnType, isNull);
+    expect(executable.isAsynchronous, isFalse);
     expect(executable.isExternal, isFalse);
+    expect(executable.isGenerator, isFalse);
     expect(executable.nameOffset, text.indexOf('C();'));
     expect(executable.periodOffset, 0);
     expect(executable.nameEnd, 0);
     expect(executable.isRedirectedConstructor, isFalse);
     expect(executable.redirectedConstructor, isNull);
     expect(executable.redirectedConstructorName, isEmpty);
     expect(executable.visibleOffset, 0);
     expect(executable.visibleLength, 0);
   }
 
@@ skipping 1575 matching lines @@
     UnlinkedExecutable executable =
         serializeClassText('abstract class C { f() {} }').executables[0];
     expect(executable.isAbstract, isFalse);
   }
 
   test_executable_function() {
     String text = '  f() {}';
     UnlinkedExecutable executable = serializeExecutableText(text);
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.returnType, isNull);
+    expect(executable.isAsynchronous, isFalse);
     expect(executable.isExternal, isFalse);
+    expect(executable.isGenerator, isFalse);
     expect(executable.nameOffset, text.indexOf('f'));
     expect(executable.visibleOffset, 0);
     expect(executable.visibleLength, 0);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         ReferenceKind.topLevelFunction);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'f');
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
   }
 
+  test_executable_function_async() {
+    UnlinkedExecutable executable = serializeExecutableText(r'''
+import 'dart:async';
+Future f() async {}
+''');
+    expect(executable.isAsynchronous, isTrue);
+    expect(executable.isGenerator, isFalse);
+  }
+
+  test_executable_function_asyncStar() {
+    UnlinkedExecutable executable = serializeExecutableText(r'''
+import 'dart:async';
+Stream f() async* {}
+''');
+    expect(executable.isAsynchronous, isTrue);
+    expect(executable.isGenerator, isTrue);
+  }
+
   test_executable_function_explicit_return() {
     UnlinkedExecutable executable =
         serializeExecutableText('dynamic f() => null;');
     checkDynamicTypeRef(executable.returnType);
   }
 
   test_executable_function_external() {
     UnlinkedExecutable executable = serializeExecutableText('external f();');
     expect(executable.isExternal, isTrue);
   }
 
   test_executable_function_private() {
     serializeExecutableText('_f() {}', executableName: '_f');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_executable_getter() {
     String text = 'int get f => 1;';
     UnlinkedExecutable executable = serializeExecutableText(text);
     expect(executable.kind, UnlinkedExecutableKind.getter);
     expect(executable.returnType, isNotNull);
+    expect(executable.isAsynchronous, isFalse);
     expect(executable.isExternal, isFalse);
+    expect(executable.isGenerator, isFalse);
     expect(executable.nameOffset, text.indexOf('f'));
     expect(findVariable('f'), isNull);
     expect(findExecutable('f='), isNull);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         ReferenceKind.topLevelPropertyAccessor);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'f');
   }
 
   test_executable_getter_external() {
@@ skipping 412 matching lines @@
       _assertVariableVisible(code, v, '{ // 1', '} // 2');
       checkTypeRef(v.type, 'dart:core', 'dart:core', 'int');
     }
   }
 
   test_executable_member_function() {
     UnlinkedExecutable executable = findExecutable('f',
         executables: serializeClassText('class C { f() {} }').executables);
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.returnType, isNull);
+    expect(executable.isAsynchronous, isFalse);
     expect(executable.isExternal, isFalse);
+    expect(executable.isGenerator, isFalse);
     expect(executable.visibleOffset, 0);
     expect(executable.visibleLength, 0);
     _assertCodeRange(executable.codeRange, 10, 6);
   }
 
+  test_executable_member_function_async() {
+    UnlinkedExecutable executable =
+        findExecutable('f', executables: serializeClassText(r'''
+import 'dart:async';
+class C {
+  Future f() async {}
+}
+''').executables);
+    expect(executable.isAsynchronous, isTrue);
+    expect(executable.isGenerator, isFalse);
+  }
+
+  test_executable_member_function_asyncStar() {
+    UnlinkedExecutable executable =
+        findExecutable('f', executables: serializeClassText(r'''
+import 'dart:async';
+class C {
+  Stream f() async* {}
+}
+''').executables);
+    expect(executable.isAsynchronous, isTrue);
+    expect(executable.isGenerator, isTrue);
+  }
+
   test_executable_member_function_explicit_return() {
     UnlinkedExecutable executable = findExecutable('f',
         executables:
             serializeClassText('class C { dynamic f() => null; }').executables);
     expect(executable.returnType, isNotNull);
   }
 
   test_executable_member_function_external() {
     UnlinkedExecutable executable = findExecutable('f',
         executables:
             serializeClassText('class C { external f(); }').executables);
     expect(executable.isExternal, isTrue);
   }
 
   test_executable_member_getter() {
     UnlinkedClass cls = serializeClassText('class C { int get f => 1; }');
     UnlinkedExecutable executable =
         findExecutable('f', executables: cls.executables, failIfAbsent: true);
     expect(executable.kind, UnlinkedExecutableKind.getter);
     expect(executable.returnType, isNotNull);
+    expect(executable.isAsynchronous, isFalse);
     expect(executable.isExternal, isFalse);
+    expect(executable.isGenerator, isFalse);
     _assertCodeRange(executable.codeRange, 10, 15);
     expect(findVariable('f', variables: cls.fields), isNull);
     expect(findExecutable('f=', executables: cls.executables), isNull);
   }
 
   test_executable_member_getter_external() {
     UnlinkedClass cls = serializeClassText('class C { external int get f; }');
     UnlinkedExecutable executable =
         findExecutable('f', executables: cls.executables, failIfAbsent: true);
     expect(executable.isExternal, isTrue);
   }
 
   test_executable_member_setter() {
     UnlinkedClass cls = serializeClassText('class C { void set f(value) {} }');
     UnlinkedExecutable executable =
         findExecutable('f=', executables: cls.executables, failIfAbsent: true);
     expect(executable.kind, UnlinkedExecutableKind.setter);
     expect(executable.returnType, isNotNull);
+    expect(executable.isAsynchronous, isFalse);
     expect(executable.isExternal, isFalse);
+    expect(executable.isGenerator, isFalse);
     _assertCodeRange(executable.codeRange, 10, 20);
     expect(findVariable('f', variables: cls.fields), isNull);
     expect(findExecutable('f', executables: cls.executables), isNull);
   }
 
   test_executable_member_setter_external() {
     UnlinkedClass cls =
         serializeClassText('class C { external void set f(value); }');
     UnlinkedExecutable executable =
         findExecutable('f=', executables: cls.executables, failIfAbsent: true);
@@ skipping 33 matching lines @@
   }
 
   test_executable_operator() {
     UnlinkedExecutable executable =
         serializeClassText('class C { C operator+(C c) => null; }').executables[
             0];
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.name, '+');
     expect(executable.returnType, isNotNull);
     expect(executable.isAbstract, false);
+    expect(executable.isAsynchronous, isFalse);
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
+    expect(executable.isGenerator, isFalse);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(1));
     checkTypeRef(executable.returnType, null, null, 'C');
     expect(executable.typeParameters, isEmpty);
     expect(executable.isExternal, false);
   }
 
   test_executable_operator_abstract() {
     UnlinkedExecutable executable =
         serializeClassText('class C { C operator+(C c); }', allowErrors: true)
             .executables[0];
     expect(executable.isAbstract, true);
+    expect(executable.isAsynchronous, isFalse);
     expect(executable.isExternal, false);
+    expect(executable.isGenerator, isFalse);
   }
 
   test_executable_operator_equal() {
     UnlinkedExecutable executable = serializeClassText(
             'class C { bool operator==(Object other) => false; }')
         .executables[0];
     expect(executable.name, '==');
   }
 
   test_executable_operator_external() {
     UnlinkedExecutable executable =
         serializeClassText('class C { external C operator+(C c); }')
             .executables[0];
     expect(executable.isAbstract, false);
+    expect(executable.isAsynchronous, isFalse);
     expect(executable.isExternal, true);
+    expect(executable.isGenerator, isFalse);
   }
 
   test_executable_operator_greater_equal() {
     UnlinkedExecutable executable =
         serializeClassText('class C { bool operator>=(C other) => false; }')
             .executables[0];
     expect(executable.name, '>=');
   }
 
   test_executable_operator_index() {
@@ skipping 230 matching lines @@
     UnlinkedExecutable executable = serializeExecutableText('void f() {}');
     checkVoidTypeRef(executable.returnType);
   }
 
   test_executable_setter() {
     String text = 'void set f(value) {}';
     UnlinkedExecutable executable =
         serializeExecutableText(text, executableName: 'f=');
     expect(executable.kind, UnlinkedExecutableKind.setter);
     expect(executable.returnType, isNotNull);
+    expect(executable.isAsynchronous, isFalse);
     expect(executable.isExternal, isFalse);
+    expect(executable.isGenerator, isFalse);
     expect(executable.nameOffset, text.indexOf('f'));
     expect(findVariable('f'), isNull);
     expect(findExecutable('f'), isNull);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         ReferenceKind.topLevelPropertyAccessor);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'f=');
   }
 
   test_executable_setter_external() {
@@ skipping 3945 matching lines @@
 class _PrefixExpectation {
   final ReferenceKind kind;
   final String name;
   final String absoluteUri;
   final String relativeUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
       {this.absoluteUri, this.relativeUri, this.numTypeParameters: 0});
 }