Drop implicit types from summaries.

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/generated/engine.dart';
@@ skipping 30 matching lines @@
       analysisContext.typeProvider.objectType.element.library,
       analysisContext.typeProvider.futureType.element.library
     ];
     for (LibraryElement library in libraries) {
       summarize_elements.LibrarySerializationResult serializedLibrary =
           summarize_elements.serializeLibrary(
               library, analysisContext.typeProvider);
       for (int i = 0; i < serializedLibrary.unlinkedUnits.length; i++) {
         uriToNamespace[serializedLibrary.unitUris[i]] =
             new UnlinkedUnit.fromBuffer(
-                    serializedLibrary.unlinkedUnits[i].toBuffer())
-                .publicNamespace;
+                serializedLibrary.unlinkedUnits[i].toBuffer()).publicNamespace;
       }
     }
     return uriToNamespace;
   } catch (_) {
     return null;
   }
 }();
 
 /**
  * Convert a summary object (or a portion of one) into a canonical form that
@@ skipping 692 matching lines @@
 
   /**
    * Serialize a type declaration using the given [text] as a type name, and
    * return a summary of the corresponding [EntityRef].  If the type
    * declaration needs to refer to types that are not available in core, those
    * types may be declared in [otherDeclarations].
    */
   EntityRef serializeTypeText(String text,
       {String otherDeclarations: '', bool allowErrors: false}) {
     return serializeVariableText('$otherDeclarations\n$text v;',
-            allowErrors: allowErrors)
-        .type;
+        allowErrors: allowErrors).type;
   }
 
   /**
    * Serialize the given library [text] and return the summary of the variable
    * with the given [variableName].
    */
   UnlinkedVariable serializeVariableText(String text,
       {String variableName: 'v', bool allowErrors: false}) {
     serializeLibraryText(text, allowErrors: allowErrors);
     return findVariable(variableName, failIfAbsent: true);
@@ skipping 774 matching lines @@
       ''
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_length() {
     UnlinkedVariable variable =
         serializeVariableText('const v = "abc".length;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.length
-    ], strings: [
-      'abc'
-    ]);
+    _assertUnlinkedConst(variable.constExpr,
+        operators:
+            [UnlinkedConstOperation.pushString, UnlinkedConstOperation.length],
+        strings: ['abc']);
   }
 
   test_constExpr_makeList_typed() {
     UnlinkedVariable variable =
         serializeVariableText('const v = const <int>[11, 22, 33];');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.makeList
+      UnlinkedConstOperation.makeTypedList
     ], ints: [
       11,
       22,
       33,
       3
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
-  test_constExpr_makeList_untyped() {
+  test_constExpr_makeList_typed_dynamic() {
     UnlinkedVariable variable =
-        serializeVariableText('const v = const [11, 22, 33];');
+        serializeVariableText('const v = const <dynamic>[11, 22, 33];');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.makeList
+      UnlinkedConstOperation.makeTypedList
     ], ints: [
       11,
       22,
       33,
       3
     ], referenceValidators: [
       (EntityRef r) => checkDynamicTypeRef(r)
     ]);
   }
 
+  test_constExpr_makeList_untyped() {

[scheglov, 2016/01/22 19:39:52]

I try to name tests using the name of the operation they test.
So, this test would be better to name "test_constExpr_makeUntypedList".

Actually all the other makeList / makeMap were renamed, all these tests would be
good to rename.

[Paul Berry, 2016/01/22 19:54:38]

Done.

+    UnlinkedVariable variable =
+        serializeVariableText('const v = const [11, 22, 33];');
+    _assertUnlinkedConst(variable.constExpr, operators: [
+      UnlinkedConstOperation.pushInt,
+      UnlinkedConstOperation.pushInt,
+      UnlinkedConstOperation.pushInt,
+      UnlinkedConstOperation.makeUntypedList
+    ], ints: [
+      11,
+      22,
+      33,
+      3
+    ]);
+  }
+
   test_constExpr_makeMap_typed() {
     UnlinkedVariable variable = serializeVariableText(
         'const v = const <int, String>{11: "aaa", 22: "bbb", 33: "ccc"};');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.makeMap
+      UnlinkedConstOperation.makeTypedMap
     ], ints: [
       11,
       22,
       33,
       3
     ], strings: [
       'aaa',
       'bbb',
       'ccc'
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int',
           expectedKind: ReferenceKind.classOrEnum),
       (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'String',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
-  test_constExpr_makeMap_untyped() {
+  test_constExpr_makeMap_typed_dynamic() {
     UnlinkedVariable variable = serializeVariableText(
-        'const v = const {11: "aaa", 22: "bbb", 33: "ccc"};');
+        'const v = const <dynamic, dynamic>{11: "aaa", 22: "bbb", 33: "ccc"};');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.makeMap
+      UnlinkedConstOperation.makeTypedMap
     ], ints: [
       11,
       22,
       33,
       3
     ], strings: [
       'aaa',
       'bbb',
       'ccc'
     ], referenceValidators: [
       (EntityRef r) => checkDynamicTypeRef(r),
       (EntityRef r) => checkDynamicTypeRef(r)
     ]);
   }
 
+  test_constExpr_makeMap_untyped() {
+    UnlinkedVariable variable = serializeVariableText(
+        'const v = const {11: "aaa", 22: "bbb", 33: "ccc"};');
+    _assertUnlinkedConst(variable.constExpr, operators: [
+      UnlinkedConstOperation.pushInt,
+      UnlinkedConstOperation.pushString,
+      UnlinkedConstOperation.pushInt,
+      UnlinkedConstOperation.pushString,
+      UnlinkedConstOperation.pushInt,
+      UnlinkedConstOperation.pushString,
+      UnlinkedConstOperation.makeUntypedMap
+    ], ints: [
+      11,
+      22,
+      33,
+      3
+    ], strings: [
+      'aaa',
+      'bbb',
+      'ccc'
+    ]);
+  }
+
   test_constExpr_makeSymbol() {
     UnlinkedVariable variable = serializeVariableText('const v = #a.bb.ccc;');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.makeSymbol
     ], strings: [
       'a.bb.ccc'
     ]);
   }
 
   test_constExpr_parenthesized() {
     UnlinkedVariable variable = serializeVariableText('const v = (1 + 2) * 3;');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.add,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.multiply,
     ], ints: [
       1,
       2,
       3
     ]);
   }
 
   test_constExpr_prefix_complement() {
     UnlinkedVariable variable = serializeVariableText('const v = ~2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.complement
-    ], ints: [
-      2
-    ]);
+    _assertUnlinkedConst(variable.constExpr,
+        operators:
+            [UnlinkedConstOperation.pushInt, UnlinkedConstOperation.complement],
+        ints: [2]);
   }
 
   test_constExpr_prefix_negate() {
     UnlinkedVariable variable = serializeVariableText('const v = -(2);');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.negate
-    ], ints: [
-      2
-    ]);
+    _assertUnlinkedConst(variable.constExpr,
+        operators:
+            [UnlinkedConstOperation.pushInt, UnlinkedConstOperation.negate],
+        ints: [2]);
   }
 
   test_constExpr_prefix_not() {
     UnlinkedVariable variable = serializeVariableText('const v = !true;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushTrue,
-      UnlinkedConstOperation.not
-    ]);
+    _assertUnlinkedConst(variable.constExpr, operators:
+        [UnlinkedConstOperation.pushTrue, UnlinkedConstOperation.not]);
   }
 
   test_constExpr_pushDouble() {
     UnlinkedVariable variable = serializeVariableText('const v = 123.4567;');
     _assertUnlinkedConst(variable.constExpr,
         operators: [UnlinkedConstOperation.pushDouble], doubles: [123.4567]);
   }
 
   test_constExpr_pushFalse() {
     UnlinkedVariable variable = serializeVariableText('const v = false;');
     _assertUnlinkedConst(variable.constExpr,
         operators: [UnlinkedConstOperation.pushFalse]);
   }
 
   test_constExpr_pushInt() {
     UnlinkedVariable variable = serializeVariableText('const v = 1;');
     _assertUnlinkedConst(variable.constExpr,
         operators: [UnlinkedConstOperation.pushInt], ints: [1]);
   }
 
   test_constExpr_pushInt_max() {
     UnlinkedVariable variable = serializeVariableText('const v = 0xFFFFFFFF;');
     _assertUnlinkedConst(variable.constExpr,
         operators: [UnlinkedConstOperation.pushInt,], ints: [0xFFFFFFFF]);
   }
 
   test_constExpr_pushInt_negative() {
     UnlinkedVariable variable = serializeVariableText('const v = -5;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.negate
-    ], ints: [
-      5
-    ]);
+    _assertUnlinkedConst(variable.constExpr,
+        operators:
+            [UnlinkedConstOperation.pushInt, UnlinkedConstOperation.negate],
+        ints: [5]);
   }
 
   test_constExpr_pushInt_shiftOr_long() {
     UnlinkedVariable variable =
         serializeVariableText('const v = 0xA123456789ABCDEF012345678;');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.shiftOr,
       UnlinkedConstOperation.shiftOr,
       UnlinkedConstOperation.shiftOr
     ], ints: [
       0xA,
       0x12345678,
       0x9ABCDEF0,
       0x12345678
     ]);
   }
 
   test_constExpr_pushInt_shiftOr_min() {
     UnlinkedVariable variable = serializeVariableText('const v = 0x100000000;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.shiftOr,
-    ], ints: [
-      1,
-      0,
-    ]);
+    _assertUnlinkedConst(variable.constExpr,
+        operators:
+            [UnlinkedConstOperation.pushInt, UnlinkedConstOperation.shiftOr,],
+        ints: [1, 0,]);
   }
 
   test_constExpr_pushInt_shiftOr_min2() {
     UnlinkedVariable variable =
         serializeVariableText('const v = 0x10000000000000000;');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.shiftOr,
       UnlinkedConstOperation.shiftOr,
     ], ints: [
@@ skipping 154 matching lines @@
     UnlinkedVariable variable = serializeVariableText('const v = true;');
     _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.hasImplicitReturnType, isFalse);
+    expect(executable.returnType, isNull);
     expect(executable.isExternal, isFalse);
     expect(executable.nameOffset, text.indexOf('C();'));
   }
 
   test_constructor_anonymous() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(); }').executables);
     expect(executable.name, isEmpty);
   }
 
@@ skipping 74 matching lines @@
   test_constructor_initializing_formal_function_typed_explicit_return_type() {
     UnlinkedExecutable executable = findExecutable('',
         executables:
             serializeClassText('class C { C(int this.x()); Function x; }')
                 .executables);
     UnlinkedParam parameter = executable.parameters[0];
     checkTypeRef(parameter.type, 'dart:core', 'dart:core', 'int');
   }
 
   test_constructor_initializing_formal_function_typed_implicit_return_type() {
+    if (!checkAstDerivedData) {
+      // TODO(paulberry): this test fails when building the summary from the
+      // element model because the elment model doesn't record whether a
+      // function-typed parameter's return type is implicit.
+      return;
+    }
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(this.x()); Function x; }')
             .executables);
     UnlinkedParam parameter = executable.parameters[0];
-    // Since the parameter is function-typed it is considered to have an
-    // explicit type, even though that explicit type itself has an implicit
-    // return type.
-    expect(parameter.hasImplicitType, isFalse);
-    checkDynamicTypeRef(parameter.type);
+    expect(parameter.isFunctionTyped, isTrue);
+    expect(parameter.type, isNull);
   }
 
   test_constructor_initializing_formal_function_typed_no_parameters() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(this.x()); final x; }')
             .executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.parameters, isEmpty);
   }
 
@@ skipping 16 matching lines @@
   }
 
   test_constructor_initializing_formal_implicit_type() {
     // Note: the implicit type of an initializing formal is the type of the
     // field.
     UnlinkedExecutable executable = findExecutable('',
         executables:
             serializeClassText('class C { C(this.x); int x; }').executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.type, isNull);
-    expect(parameter.hasImplicitType, isTrue);
   }
 
   test_constructor_initializing_formal_name() {
     UnlinkedExecutable executable = findExecutable('',
         executables:
             serializeClassText('class C { C(this.x); final x; }').executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.name, 'x');
   }
 
@@ skipping 282 matching lines @@
   test_executable_concrete() {
     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.hasImplicitReturnType, isTrue);
-    checkDynamicTypeRef(executable.returnType);
+    expect(executable.returnType, isNull);
     expect(executable.isExternal, isFalse);
     expect(executable.nameOffset, text.indexOf('f'));
     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_explicit_return() {
     UnlinkedExecutable executable =
         serializeExecutableText('dynamic f() => null;');
-    expect(executable.hasImplicitReturnType, isFalse);
     checkDynamicTypeRef(executable.returnType);
   }
 
   test_executable_function_external() {
     UnlinkedExecutable executable = serializeExecutableText('external f();');
     expect(executable.isExternal, isTrue);
   }
 
   test_executable_function_private() {
     serializeExecutableText('_f() {}', '_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.hasImplicitReturnType, isFalse);
+    expect(executable.returnType, isNotNull);
     expect(executable.isExternal, 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() {
     UnlinkedExecutable executable =
         serializeExecutableText('external int get f;');
     expect(executable.isExternal, isTrue);
   }
 
   test_executable_getter_private() {
     serializeExecutableText('int get _f => 1;', '_f');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_executable_getter_type() {
     UnlinkedExecutable executable = serializeExecutableText('int get f => 1;');
     checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'int');
     expect(executable.parameters, isEmpty);
   }
 
   test_executable_getter_type_implicit() {
     UnlinkedExecutable executable = serializeExecutableText('get f => 1;');
-    checkDynamicTypeRef(executable.returnType);
-    expect(executable.hasImplicitReturnType, isTrue);
+    expect(executable.returnType, isNull);
     expect(executable.parameters, isEmpty);
   }
 
   test_executable_member_function() {
     UnlinkedExecutable executable = findExecutable('f',
         executables: serializeClassText('class C { f() {} }').executables);
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
-    expect(executable.hasImplicitReturnType, isTrue);
+    expect(executable.returnType, isNull);
     expect(executable.isExternal, isFalse);
   }
 
   test_executable_member_function_explicit_return() {
     UnlinkedExecutable executable = findExecutable('f',
         executables:
             serializeClassText('class C { dynamic f() => null; }').executables);
-    expect(executable.hasImplicitReturnType, isFalse);
+    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.hasImplicitReturnType, isFalse);
+    expect(executable.returnType, isNotNull);
     expect(executable.isExternal, isFalse);
     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.hasImplicitReturnType, isFalse);
+    expect(executable.returnType, isNotNull);
     expect(executable.isExternal, isFalse);
     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);
     expect(executable.isExternal, isTrue);
   }
 
   test_executable_member_setter_implicit_return() {
     UnlinkedClass cls = serializeClassText('class C { set f(value) {} }');
     UnlinkedExecutable executable =
         findExecutable('f=', executables: cls.executables, failIfAbsent: true);
-    expect(executable.hasImplicitReturnType, isTrue);
-    checkDynamicTypeRef(executable.returnType);
+    expect(executable.returnType, isNull);
   }
 
   test_executable_name() {
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
     expect(executable.name, 'f');
   }
 
   test_executable_no_flags() {
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
     expect(executable.isAbstract, isFalse);
@@ skipping 13 matching lines @@
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
     expect(executable.isStatic, isFalse);
   }
 
   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.hasImplicitReturnType, false);
+    expect(executable.returnType, isNotNull);
     expect(executable.isAbstract, false);
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(1));
     checkTypeRef(executable.returnType, null, null, 'C');
     expect(executable.typeParameters, isEmpty);
     expect(executable.isExternal, false);
   }
 
@@ skipping 16 matching lines @@
             .executables[0];
     expect(executable.name, '>=');
   }
 
   test_executable_operator_index() {
     UnlinkedExecutable executable =
         serializeClassText('class C { bool operator[](int i) => null; }')
             .executables[0];
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.name, '[]');
-    expect(executable.hasImplicitReturnType, false);
+    expect(executable.returnType, isNotNull);
     expect(executable.isAbstract, false);
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(1));
     checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'bool');
     expect(executable.typeParameters, isEmpty);
   }
 
   test_executable_operator_index_set() {
     UnlinkedExecutable executable = serializeClassText(
-            'class C { void operator[]=(int i, bool v) => null; }')
-        .executables[0];
+        'class C { void operator[]=(int i, bool v) => null; }').executables[0];
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.name, '[]=');
-    expect(executable.hasImplicitReturnType, false);
+    expect(executable.returnType, isNotNull);
     expect(executable.isAbstract, false);
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(2));
     checkVoidTypeRef(executable.returnType);
     expect(executable.typeParameters, isEmpty);
   }
 
   test_executable_operator_less_equal() {
     UnlinkedExecutable executable =
         serializeClassText('class C { bool operator<=(C other) => false; }')
             .executables[0];
     expect(executable.name, '<=');
   }
 
   test_executable_param_function_typed() {
+    if (!checkAstDerivedData) {
+      // TODO(paulberry): this test fails when building the summary from the
+      // element model because the elment model doesn't record whether a
+      // function-typed parameter's return type is implicit.
+      return;
+    }
     UnlinkedExecutable executable = serializeExecutableText('f(g()) {}');
     expect(executable.parameters[0].isFunctionTyped, isTrue);
-    // Since the parameter is function-typed it is considered to have an
-    // explicit type, even though that explicit type itself has an implicit
-    // return type.
-    expect(executable.parameters[0].hasImplicitType, isFalse);
+    expect(executable.parameters[0].type, isNull);
   }
 
   test_executable_param_function_typed_explicit_return_type() {
     UnlinkedExecutable executable =
         serializeExecutableText('f(dynamic g()) {}');
-    expect(executable.parameters[0].hasImplicitType, isFalse);
+    expect(executable.parameters[0].type, isNotNull);
   }
 
   test_executable_param_function_typed_param() {
     UnlinkedExecutable executable = serializeExecutableText('f(g(x)) {}');
     expect(executable.parameters[0].parameters, hasLength(1));
   }
 
   test_executable_param_function_typed_param_none() {
     UnlinkedExecutable executable = serializeExecutableText('f(g()) {}');
     expect(executable.parameters[0].parameters, isEmpty);
   }
 
   test_executable_param_function_typed_param_order() {
     UnlinkedExecutable executable = serializeExecutableText('f(g(x, y)) {}');
     expect(executable.parameters[0].parameters, hasLength(2));
     expect(executable.parameters[0].parameters[0].name, 'x');
     expect(executable.parameters[0].parameters[1].name, 'y');
   }
 
   test_executable_param_function_typed_return_type() {
     UnlinkedExecutable executable = serializeExecutableText('f(int g()) {}');
     checkTypeRef(
         executable.parameters[0].type, 'dart:core', 'dart:core', 'int');
   }
 
   test_executable_param_function_typed_return_type_implicit() {
+    if (!checkAstDerivedData) {
+      // TODO(paulberry): this test fails when building the summary from the
+      // element model because the elment model doesn't record whether a
+      // function-typed parameter's return type is implicit.
+      return;
+    }
     UnlinkedExecutable executable = serializeExecutableText('f(g()) {}');
-    checkDynamicTypeRef(executable.parameters[0].type);
+    expect(executable.parameters[0].isFunctionTyped, isTrue);
+    expect(executable.parameters[0].type, isNull);
   }
 
   test_executable_param_function_typed_return_type_void() {
     UnlinkedExecutable executable = serializeExecutableText('f(void g()) {}');
     checkVoidTypeRef(executable.parameters[0].type);
   }
 
   test_executable_param_kind_named() {
     UnlinkedExecutable executable = serializeExecutableText('f({x}) {}');
     expect(executable.parameters[0].kind, UnlinkedParamKind.named);
@@ skipping 36 matching lines @@
   test_executable_param_order() {
     UnlinkedExecutable executable = serializeExecutableText('f(x, y) {}');
     expect(executable.parameters, hasLength(2));
     expect(executable.parameters[0].name, 'x');
     expect(executable.parameters[1].name, 'y');
   }
 
   test_executable_param_type_explicit() {
     UnlinkedExecutable executable = serializeExecutableText('f(dynamic x) {}');
     checkDynamicTypeRef(executable.parameters[0].type);
-    expect(executable.parameters[0].hasImplicitType, isFalse);
   }
 
   test_executable_param_type_implicit() {
     UnlinkedExecutable executable = serializeExecutableText('f(x) {}');
-    checkDynamicTypeRef(executable.parameters[0].type);
-    expect(executable.parameters[0].hasImplicitType, isTrue);
+    expect(executable.parameters[0].type, isNull);
   }
 
   test_executable_return_type() {
     UnlinkedExecutable executable = serializeExecutableText('int f() => 1;');
     checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'int');
-    expect(executable.hasImplicitReturnType, isFalse);
   }
 
   test_executable_return_type_implicit() {
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
-    checkDynamicTypeRef(executable.returnType);
-    expect(executable.hasImplicitReturnType, isTrue);
+    expect(executable.returnType, isNull);
   }
 
   test_executable_return_type_void() {
     UnlinkedExecutable executable = serializeExecutableText('void f() {}');
     checkVoidTypeRef(executable.returnType);
   }
 
   test_executable_setter() {
     String text = 'void set f(value) {}';
     UnlinkedExecutable executable = serializeExecutableText(text, 'f=');
     expect(executable.kind, UnlinkedExecutableKind.setter);
-    expect(executable.hasImplicitReturnType, isFalse);
+    expect(executable.returnType, isNotNull);
     expect(executable.isExternal, 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() {
     UnlinkedExecutable executable =
         serializeExecutableText('external void set f(value);', 'f=');
     expect(executable.isExternal, isTrue);
   }
 
   test_executable_setter_implicit_return() {
     UnlinkedExecutable executable =
         serializeExecutableText('set f(value) {}', 'f=');
-    expect(executable.hasImplicitReturnType, isTrue);
-    checkDynamicTypeRef(executable.returnType);
+    expect(executable.returnType, isNull);
   }
 
   test_executable_setter_private() {
     serializeExecutableText('void set _f(value) {}', '_f=');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_executable_setter_type() {
     UnlinkedExecutable executable =
         serializeExecutableText('void set f(int value) {}', 'f=');
@@ skipping 629 matching lines @@
     checkUnresolvedTypeRef(
         serializeTypeText('dynamic.T', allowErrors: true), 'dynamic', 'T');
   }
 
   test_invalid_prefix_type_parameter() {
     if (checkAstDerivedData) {
       // TODO(paulberry): get this to work properly.
       return;
     }
     checkUnresolvedTypeRef(
-        serializeClassText('class C<T> { T.U x; }', allowErrors: true)
-            .fields[0]
+        serializeClassText('class C<T> { T.U x; }', allowErrors: true).fields[0]
             .type,
         'T',
         'U');
   }
 
   test_invalid_prefix_void() {
     if (checkAstDerivedData) {
       // TODO(paulberry): get this to work properly.
       return;
     }
@@ skipping 651 matching lines @@
  */
 var v;''';
     UnlinkedVariable variable = serializeVariableText(text);
     expect(variable.documentationComment, isNotNull);
     checkDocumentationComment(variable.documentationComment, text);
   }
 
   test_variable_explicit_dynamic() {
     UnlinkedVariable variable = serializeVariableText('dynamic v;');
     checkDynamicTypeRef(variable.type);
-    expect(variable.hasImplicitType, isFalse);
   }
 
   test_variable_final_top_level() {
     UnlinkedVariable variable =
         serializeVariableText('final int i = 0;', variableName: 'i');
     expect(variable.isFinal, isTrue);
   }
 
   test_variable_implicit_dynamic() {
     UnlinkedVariable variable = serializeVariableText('var v;');
-    checkDynamicTypeRef(variable.type);
-    expect(variable.hasImplicitType, isTrue);
+    expect(variable.type, isNull);
   }
 
   test_variable_name() {
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     expect(variable.name, 'i');
   }
 
   test_variable_no_flags() {
     UnlinkedVariable variable =
@@ skipping 109 matching lines @@
     expect(constExpr.operations, operators);
     expect(constExpr.ints, ints);
     expect(constExpr.doubles, doubles);
     expect(constExpr.strings, strings);
     expect(constExpr.references, hasLength(referenceValidators.length));
     for (int i = 0; i < referenceValidators.length; i++) {
       referenceValidators[i](constExpr.references[i]);
     }
   }
 }