Keep all type arguments in summaries - dynamic or not.

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 145 matching lines @@
    * that summaries need, so that this flag is no longer needed.
    */
   bool get checkAstDerivedData;
 
   /**
    * Get access to the linked defining compilation unit.
    */
   LinkedUnit get definingUnit => linked.units[0];
 
   /**
+   * `true` if element model was used to produce summary.
+   */
+  bool get elementMode;

[Paul Berry, 2016/05/06 18:11:38]

This is redundant.  Use `!checkAstDerivedData` instead (which is equivalent).

[scheglov, 2016/05/06 19:12:36]

Done.

+
+  /**
    * `true` if the linked portion of the summary is expected to contain
    * absolute URIs.  This happens because the element model doesn't (yet) store
    * enough information to recover relative URIs, TODO(paulberry): fix this.
    */
   bool get expectAbsoluteUrisInDependencies;
 
   /**
    * Get access to the linked summary that results from serializing and
    * then deserializing the library under test.
    */
@@ skipping 174 matching lines @@
     return null;
   }
 
   /**
    * Test an inferred type.  If [onlyInStrongMode] is `true` (the default) and
    * strong mode is disabled, verify that the given [slotId] exists and has no
    * associated type.  Otherwise, behave as in [checkLinkedTypeSlot].
    */
   void checkInferredTypeSlot(
       int slotId, String absoluteUri, String relativeUri, String expectedName,
-      {bool allowTypeParameters: false,
+      {int numTypeArguments: 0,
       ReferenceKind expectedKind: ReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
       LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
       int numTypeParameters: 0,
       bool onlyInStrongMode: true}) {
     if (strongMode || !onlyInStrongMode) {
       checkLinkedTypeSlot(slotId, absoluteUri, relativeUri, expectedName,
-          allowTypeArguments: allowTypeParameters,
+          numTypeArguments: numTypeArguments,
           expectedKind: expectedKind,
           expectedTargetUnit: expectedTargetUnit,
           linkedSourceUnit: linkedSourceUnit,
           unlinkedSourceUnit: unlinkedSourceUnit,
           numTypeParameters: numTypeParameters);
     } else {
       // A slot id should have been assigned but it should not be associated
       // with any type.
       expect(slotId, isNot(0));
       expect(getTypeRefForSlot(slotId, linkedSourceUnit: linkedSourceUnit),
@@ skipping 13 matching lines @@
       relativeUri = absoluteUri;
     }
     for (LinkedDependency dep in linked.dependencies) {
       if (dep.uri == relativeUri) {
         fail('Unexpected dependency found: $relativeUri');
       }
     }
   }
 
   /**
+   * Verify that the given [typeRef] represents the type `dynamic`.
+   */
+  void checkLinkedDynamicTypeRef(EntityRef typeRef) {
+    checkLinkedTypeRef(typeRef, null, null, 'dynamic');
+  }
+
+  /**
    * Verify that the given [typeRef] represents a reference to a type declared
    * in a file reachable via [absoluteUri] and [relativeUri], having name
-   * [expectedName].  If [allowTypeArguments] is true, allow the type
-   * reference to supply type arguments.  [expectedKind] is the kind of object
+   * [expectedName].  Verify that the number of type arguments
+   * is equal to [numTypeArguments].  [expectedKind] is the kind of object
    * referenced.  [linkedSourceUnit] and [unlinkedSourceUnit] refer to the
    * compilation unit within which the [typeRef] appears; if not specified they
    * are assumed to refer to the defining compilation unit.
    * [expectedTargetUnit] is the index of the compilation unit in which the
    * target of the [typeRef] is expected to appear; if not specified it is
    * assumed to be the defining compilation unit.  [numTypeParameters] is the
    * number of type parameters of the thing being referred to.
    */
   void checkLinkedTypeRef(EntityRef typeRef, String absoluteUri,
       String relativeUri, String expectedName,
-      {bool allowTypeArguments: false,
+      {int numTypeArguments: 0,
       ReferenceKind expectedKind: ReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
       LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
       int numTypeParameters: 0}) {
     linkedSourceUnit ??= definingUnit;
     expect(typeRef, isNotNull,
         reason: 'No entry in linkedSourceUnit.types matching slotId');
     expect(typeRef.paramReference, 0);
     int index = typeRef.reference;
-    if (!allowTypeArguments) {
-      expect(typeRef.typeArguments, isEmpty);
-    }
+    expect(typeRef.typeArguments, hasLength(numTypeArguments));
     checkReferenceIndex(index, absoluteUri, relativeUri, expectedName,
         expectedKind: expectedKind,
         expectedTargetUnit: expectedTargetUnit,
         linkedSourceUnit: linkedSourceUnit,
         unlinkedSourceUnit: unlinkedSourceUnit,
         numTypeParameters: numTypeParameters);
   }
 
   /**
    * Verify that the given [slotId] represents a reference to a type declared
    * in a file reachable via [absoluteUri] and [relativeUri], having name
-   * [expectedName].  If [allowTypeArguments] is true, allow the type
-   * reference to supply type arguments.  [expectedKind] is the kind of object
+   * [expectedName].  Verify that the number of type arguments
+   * is equal to [numTypeArguments].  [expectedKind] is the kind of object
    * referenced.  [linkedSourceUnit] and [unlinkedSourceUnit] refer to the
    * compilation unit within which the [typeRef] appears; if not specified they
    * are assumed to refer to the defining compilation unit.
    * [expectedTargetUnit] is the index of the compilation unit in which the
    * target of the [typeRef] is expected to appear; if not specified it is
    * assumed to be the defining compilation unit.  [numTypeParameters] is the
    * number of type parameters of the thing being referred to.
    */
   void checkLinkedTypeSlot(
       int slotId, String absoluteUri, String relativeUri, String expectedName,
-      {bool allowTypeArguments: false,
+      {int numTypeArguments: 0,
       ReferenceKind expectedKind: ReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
       LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
       int numTypeParameters: 0}) {
     // Slot ids should be nonzero, since zero means "no associated slot".
     expect(slotId, isNot(0));
     if (skipFullyLinkedData) {
       return;
     }
     linkedSourceUnit ??= definingUnit;
     checkLinkedTypeRef(
         getTypeRefForSlot(slotId, linkedSourceUnit: linkedSourceUnit),
         absoluteUri,
         relativeUri,
         expectedName,
-        allowTypeArguments: allowTypeArguments,
+        numTypeArguments: numTypeArguments,
         expectedKind: expectedKind,
         expectedTargetUnit: expectedTargetUnit,
         linkedSourceUnit: linkedSourceUnit,
         unlinkedSourceUnit: unlinkedSourceUnit,
         numTypeParameters: numTypeParameters);
   }
 
   /**
    * Verify that the given [typeRef] represents a reference to a type parameter
    * having the given [deBruijnIndex].
@@ skipping 607 matching lines @@
 
   test_class_alias_private() {
     serializeClassText('class _C = _D with _E; class _D {} class _E {}',
         className: '_C');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_class_alias_reference_generic() {
     EntityRef typeRef = serializeTypeText('C',
         otherDeclarations: 'class C<D, E> = F with G; class F {} class G {}');
-    checkTypeRef(typeRef, null, null, 'C', numTypeParameters: 2);
+    checkTypeRef(typeRef, null, null, 'C',
+        numTypeParameters: 2, numTypeArguments: elementMode ? 2 : 0);
+    if (elementMode) {
+      checkDynamicTypeRef(typeRef.typeArguments[0]);
+      checkDynamicTypeRef(typeRef.typeArguments[1]);
+    }
   }
 
   test_class_alias_reference_generic_imported() {
     addNamedSource(
         '/lib.dart', 'class C<D, E> = F with G; class F {} class G {}');
     EntityRef typeRef =
         serializeTypeText('C', otherDeclarations: 'import "lib.dart";');
     checkTypeRef(typeRef, absUri('/lib.dart'), 'lib.dart', 'C',
-        numTypeParameters: 2);
+        numTypeParameters: 2, numTypeArguments: elementMode ? 2 : 0);
+    if (elementMode) {
+      checkDynamicTypeRef(typeRef.typeArguments[0]);
+      checkDynamicTypeRef(typeRef.typeArguments[1]);
+    }
   }
 
   test_class_alias_supertype() {
     UnlinkedClass cls =
         serializeClassText('class C = D with E; class D {} class E {}');
     checkTypeRef(cls.supertype, null, null, 'D');
     expect(cls.hasNoSupertype, isFalse);
   }
 
   test_class_codeRange() {
@@ skipping 192 matching lines @@
   }
 
   test_class_private() {
     serializeClassText('class _C {}', className: '_C');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_class_reference_generic() {
     EntityRef typeRef =
         serializeTypeText('C', otherDeclarations: 'class C<D, E> {}');
-    checkTypeRef(typeRef, null, null, 'C', numTypeParameters: 2);
+    checkTypeRef(typeRef, null, null, 'C',
+        numTypeParameters: 2, numTypeArguments: elementMode ? 2 : 0);
+    if (elementMode) {
+      checkDynamicTypeRef(typeRef.typeArguments[0]);
+      checkDynamicTypeRef(typeRef.typeArguments[1]);
+    }
   }
 
   test_class_reference_generic_imported() {
     addNamedSource('/lib.dart', 'class C<D, E> {}');
     EntityRef typeRef =
         serializeTypeText('C', otherDeclarations: 'import "lib.dart";');
     checkTypeRef(typeRef, absUri('/lib.dart'), 'lib.dart', 'C',
-        numTypeParameters: 2);
+        numTypeParameters: 2, numTypeArguments: elementMode ? 2 : 0);
+    if (elementMode) {
+      checkDynamicTypeRef(typeRef.typeArguments[0]);
+      checkDynamicTypeRef(typeRef.typeArguments[1]);
+    }
   }
 
   test_class_superclass() {
     UnlinkedClass cls = serializeClassText('class C {}');
     expect(cls.supertype, isNull);
     expect(cls.hasNoSupertype, isFalse);
   }
 
   test_class_superclass_explicit() {
     UnlinkedClass cls = serializeClassText('class C extends D {} class D {}');
     expect(cls.supertype, isNotNull);
     checkTypeRef(cls.supertype, null, null, 'D');
     expect(cls.hasNoSupertype, isFalse);
   }
 
   test_class_type_param_bound() {
     UnlinkedClass cls = serializeClassText('class C<T extends List> {}');
     expect(cls.typeParameters, hasLength(1));
-    expect(cls.typeParameters[0].name, 'T');
-    expect(cls.typeParameters[0].bound, isNotNull);
-    checkTypeRef(cls.typeParameters[0].bound, 'dart:core', 'dart:core', 'List',
-        numTypeParameters: 1);
+    {
+      UnlinkedTypeParam typeParameter = cls.typeParameters[0];
+      expect(typeParameter.name, 'T');
+      expect(typeParameter.bound, isNotNull);
+      checkTypeRef(typeParameter.bound, 'dart:core', 'dart:core', 'List',
+          numTypeParameters: 1, numTypeArguments: elementMode ? 1 : 0);
+      if (elementMode) {
+        checkDynamicTypeRef(typeParameter.bound.typeArguments[0]);
+      }
+    }
   }
 
   test_class_type_param_f_bound() {
     UnlinkedClass cls = serializeClassText('class C<T, U extends List<T>> {}');
     EntityRef typeArgument = cls.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 2);
   }
 
   test_class_type_param_f_bound_self_ref() {
     UnlinkedClass cls = serializeClassText('class C<T, U extends List<U>> {}');
@@ skipping 6056 matching lines @@
     serializeLibraryText('import "dart:async" as a; a.Future v;');
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(2));
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'v');
     expect(unlinkedUnits[0].publicNamespace.names[1].name, 'v=');
   }
 
   test_import_prefix_reference() {
     UnlinkedVariable variable =
         serializeVariableText('import "dart:async" as a; a.Future v;');
     checkTypeRef(variable.type, 'dart:async', 'dart:async', 'Future',
-        expectedPrefix: 'a', numTypeParameters: 1);
+        expectedPrefix: 'a',
+        numTypeParameters: 1,
+        numTypeArguments: elementMode ? 1 : 0);
+    if (elementMode) {
+      checkDynamicTypeRef(variable.type.typeArguments[0]);
+    }
   }
 
   test_import_prefixes_take_precedence_over_imported_names() {
     addNamedSource('/a.dart', 'class b {} class A');
     addNamedSource('/b.dart', 'class Cls {}');
     addNamedSource('/c.dart', 'class Cls {}');
     addNamedSource('/d.dart', 'class c {} class D');
     serializeLibraryText('''
 import 'a.dart';
 import 'b.dart' as b;
 import 'c.dart' as c;
 import 'd.dart';
 A aCls;
 b.Cls bCls;
 c.Cls cCls;
 D dCls;
 ''');
     checkTypeRef(findVariable('aCls').type, absUri('/a.dart'), 'a.dart', 'A');
     checkTypeRef(findVariable('bCls').type, absUri('/b.dart'), 'b.dart', 'Cls',
         expectedPrefix: 'b');
     checkTypeRef(findVariable('cCls').type, absUri('/c.dart'), 'c.dart', 'Cls',
         expectedPrefix: 'c');
     checkTypeRef(findVariable('dCls').type, absUri('/d.dart'), 'd.dart', 'D');
   }
 
   test_import_reference() {
     UnlinkedVariable variable =
         serializeVariableText('import "dart:async"; Future v;');
     checkTypeRef(variable.type, 'dart:async', 'dart:async', 'Future',
-        numTypeParameters: 1);
+        numTypeParameters: 1, numTypeArguments: elementMode ? 1 : 0);
+    if (elementMode) {
+      checkDynamicTypeRef(variable.type.typeArguments[0]);
+    }
   }
 
   test_import_reference_merged_no_prefix() {
     serializeLibraryText('''
 import "dart:async" show Future;
 import "dart:async" show Stream;
 
 Future f;
 Stream s;
 ''');
-    checkTypeRef(findVariable('f').type, 'dart:async', 'dart:async', 'Future',
-        numTypeParameters: 1);
-    checkTypeRef(findVariable('s').type, 'dart:async', 'dart:async', 'Stream',
-        expectedTargetUnit: 1, numTypeParameters: 1);
+    {
+      EntityRef typeRef = findVariable('f').type;
+      checkTypeRef(typeRef, 'dart:async', 'dart:async', 'Future',
+          numTypeParameters: 1, numTypeArguments: elementMode ? 1 : 0);
+      if (elementMode) {
+        checkDynamicTypeRef(typeRef.typeArguments[0]);
+      }
+    }
+    {
+      EntityRef typeRef = findVariable('s').type;
+      checkTypeRef(typeRef, 'dart:async', 'dart:async', 'Stream',
+          expectedTargetUnit: 1,
+          numTypeParameters: 1,
+          numTypeArguments: elementMode ? 1 : 0);
+      if (elementMode) {
+        checkDynamicTypeRef(typeRef.typeArguments[0]);
+      }
+    }
   }
 
   test_import_reference_merged_prefixed() {
     serializeLibraryText('''
 import "dart:async" as a show Future;
 import "dart:async" as a show Stream;
 
 a.Future f;
 a.Stream s;
 ''');
-    checkTypeRef(findVariable('f').type, 'dart:async', 'dart:async', 'Future',
-        expectedPrefix: 'a', numTypeParameters: 1);
-    checkTypeRef(findVariable('s').type, 'dart:async', 'dart:async', 'Stream',
-        expectedTargetUnit: 1, expectedPrefix: 'a', numTypeParameters: 1);
+    {
+      EntityRef typeRef = findVariable('f').type;
+      checkTypeRef(typeRef, 'dart:async', 'dart:async', 'Future',
+          expectedPrefix: 'a',
+          numTypeParameters: 1,
+          numTypeArguments: elementMode ? 1 : 0);
+      if (elementMode) {
+        checkDynamicTypeRef(typeRef.typeArguments[0]);
+      }
+    }
+    {
+      EntityRef typeRef = findVariable('s').type;
+      checkTypeRef(typeRef, 'dart:async', 'dart:async', 'Stream',
+          expectedTargetUnit: 1,
+          expectedPrefix: 'a',
+          numTypeParameters: 1,
+          numTypeArguments: elementMode ? 1 : 0);
+      if (elementMode) {
+        checkDynamicTypeRef(typeRef.typeArguments[0]);
+      }
+    }
   }
 
   test_import_reference_merged_prefixed_separate_libraries() {
     addNamedSource('/a.dart', 'class A {}');
     addNamedSource('/b.dart', 'class B {}');
     serializeLibraryText('''
 import 'a.dart' as p;
 import 'b.dart' as p;
 
 p.A a;
@@ skipping 54 matching lines @@
 
   test_inferred_type_keeps_leading_dynamic() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedClass cls =
         serializeClassText('class C { final x = <dynamic, int>{}; }');
     EntityRef type = getTypeRefForSlot(cls.fields[0].inferredTypeSlot);
     // Check that x has inferred type `Map<dynamic, int>`.
     checkLinkedTypeRef(type, 'dart:core', 'dart:core', 'Map',
-        allowTypeArguments: true, numTypeParameters: 2);
-    expect(type.typeArguments, hasLength(2));
+        numTypeParameters: 2, numTypeArguments: 2);
     checkLinkedTypeRef(type.typeArguments[0], null, null, 'dynamic');
     checkLinkedTypeRef(type.typeArguments[1], 'dart:core', 'dart:core', 'int');
   }
 
   test_inferred_type_refers_to_bound_type_param() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedClass cls = serializeClassText(
         'class C<T> extends D<int, T> { var v; }'
         ' abstract class D<U, V> { Map<V, U> get v; }',
         className: 'C');
     EntityRef type = getTypeRefForSlot(cls.fields[0].inferredTypeSlot);
     // Check that v has inferred type Map<T, int>.
     checkLinkedTypeRef(type, 'dart:core', 'dart:core', 'Map',
-        allowTypeArguments: true, numTypeParameters: 2);
+        numTypeParameters: 2, numTypeArguments: 2);
     checkParamTypeRef(type.typeArguments[0], 1);
     checkLinkedTypeRef(type.typeArguments[1], 'dart:core', 'dart:core', 'int');
   }
 
   test_inferred_type_refers_to_function_typed_param_of_typedef() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedVariable v = serializeVariableText('''
 typedef void F(int g(String s));
@@ skipping 132 matching lines @@
     checkReferenceIndex(linkedReference.containingReference, null, null, 'D');
   }
 
   test_inferred_type_skips_trailing_dynamic() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedClass cls =
         serializeClassText('class C { final x = <int, dynamic>{}; }');
     EntityRef type = getTypeRefForSlot(cls.fields[0].inferredTypeSlot);
-    // Check that x has inferred type `Map<int>`.  The trailing type argument
-    // `dynamic` is omitted.
+    // Check that x has inferred type `Map<int, dynamic>`.
     checkLinkedTypeRef(type, 'dart:core', 'dart:core', 'Map',
-        allowTypeArguments: true, numTypeParameters: 2);
-    expect(type.typeArguments, hasLength(1));
+        numTypeParameters: 2, numTypeArguments: 2);
     checkLinkedTypeRef(type.typeArguments[0], 'dart:core', 'dart:core', 'int');
+    checkLinkedDynamicTypeRef(type.typeArguments[1]);
   }
 
   test_inferred_type_skips_unnecessary_dynamic() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedClass cls = serializeClassText('class C { final x = []; }');
     EntityRef type = getTypeRefForSlot(cls.fields[0].inferredTypeSlot);
-    // Check that x has inferred type `List`, not `List<dynamic>`.
+    // Check that x has inferred type `List<dynamic>`.
     checkLinkedTypeRef(type, 'dart:core', 'dart:core', 'List',
-        numTypeParameters: 1);
+        numTypeParameters: 1, numTypeArguments: 1);
   }
 
   test_initializer_executable_with_bottom_return_type() {
     // The synthetic executable for `v` has type `() => Bottom`.
     UnlinkedVariable variable = serializeVariableText('int v = null;');
     expect(variable.initializer.returnType, isNull);
     checkInferredTypeSlot(
         variable.initializer.inferredReturnTypeSlot, null, null, '*bottom*',
         onlyInStrongMode: false);
   }
@@ skipping 1113 matching lines @@
     checkTypeRef(propagatedType.syntheticParams[0].type, 'dart:core',
         'dart:core', 'int');
     checkTypeRef(propagatedType.syntheticParams[1].type, 'dart:core',
         'dart:core', 'String');
   }
 
   test_type_arguments_explicit() {
     EntityRef typeRef = serializeTypeText('List<int>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
         numTypeParameters: 1, numTypeArguments: 1);
-    expect(typeRef.typeArguments, hasLength(1));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_explicit_dynamic() {
     EntityRef typeRef = serializeTypeText('List<dynamic>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
-        numTypeParameters: 1);
-    expect(typeRef.typeArguments, isEmpty);
+        numTypeParameters: 1, numTypeArguments: 1);
+    checkDynamicTypeRef(typeRef.typeArguments[0]);
   }
 
   test_type_arguments_explicit_dynamic_dynamic() {
     EntityRef typeRef = serializeTypeText('Map<dynamic, dynamic>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
-        numTypeParameters: 2);
-    // Trailing type arguments of type `dynamic` are omitted.
-    expect(typeRef.typeArguments, isEmpty);
+        numTypeParameters: 2, numTypeArguments: 2);
+    checkDynamicTypeRef(typeRef.typeArguments[0]);
+    checkDynamicTypeRef(typeRef.typeArguments[1]);
   }
 
   test_type_arguments_explicit_dynamic_int() {
     EntityRef typeRef = serializeTypeText('Map<dynamic, int>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
         numTypeParameters: 2, numTypeArguments: 2);
-    // Leading type arguments of type `dynamic` are not omitted.
-    expect(typeRef.typeArguments.length, 2);
     checkDynamicTypeRef(typeRef.typeArguments[0]);
     checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_explicit_dynamic_typedef() {
     EntityRef typeRef =
         serializeTypeText('F<dynamic>', otherDeclarations: 'typedef T F<T>();');
     checkTypeRef(typeRef, null, null, 'F',
         expectedKind: ReferenceKind.typedef,
         numTypeParameters: 1,
-        numTypeArguments: 0);
-    expect(typeRef.typeArguments, isEmpty);
+        numTypeArguments: 1);
+    checkDynamicTypeRef(typeRef.typeArguments[0]);
   }
 
   test_type_arguments_explicit_String_dynamic() {
     EntityRef typeRef = serializeTypeText('Map<String, dynamic>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
-        numTypeParameters: 2, numTypeArguments: 1);
-    // Trailing type arguments of type `dynamic` are omitted.
-    expect(typeRef.typeArguments.length, 1);
+        numTypeParameters: 2, numTypeArguments: 2);
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'String');
+    checkDynamicTypeRef(typeRef.typeArguments[1]);
   }
 
   test_type_arguments_explicit_String_int() {
     EntityRef typeRef = serializeTypeText('Map<String, int>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
         numTypeParameters: 2, numTypeArguments: 2);
-    expect(typeRef.typeArguments.length, 2);
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'String');
     checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_explicit_typedef() {
     EntityRef typeRef =
         serializeTypeText('F<int>', otherDeclarations: 'typedef T F<T>();');
     checkTypeRef(typeRef, null, null, 'F',
         expectedKind: ReferenceKind.typedef,
         numTypeParameters: 1,
         numTypeArguments: 1);
-    expect(typeRef.typeArguments, hasLength(1));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_implicit() {
     EntityRef typeRef = serializeTypeText('List');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
-        numTypeParameters: 1);
-    expect(typeRef.typeArguments, isEmpty);
+        numTypeParameters: 1, numTypeArguments: elementMode ? 1 : 0);
+    if (elementMode) {
+      checkDynamicTypeRef(typeRef.typeArguments[0]);
+    }
   }
 
   test_type_arguments_implicit_typedef() {
     EntityRef typeRef =
         serializeTypeText('F', otherDeclarations: 'typedef T F<T>();');
     checkTypeRef(typeRef, null, null, 'F',
         expectedKind: ReferenceKind.typedef,
         numTypeParameters: 1,
-        numTypeArguments: 0);
-    expect(typeRef.typeArguments, isEmpty);
+        numTypeArguments: elementMode ? 1 : 0);
+    if (elementMode) {
+      checkDynamicTypeRef(typeRef.typeArguments[0]);
+    }
+  }
+
+  test_type_arguments_implicit_typedef_withBound() {
+    EntityRef typeRef = serializeTypeText('F',
+        otherDeclarations: 'typedef T F<T extends num>();');
+    checkTypeRef(typeRef, null, null, 'F',
+        expectedKind: ReferenceKind.typedef,
+        numTypeParameters: 1,
+        numTypeArguments: elementMode ? 1 : 0);
+    if (elementMode) {
+      if (strongMode) {
+        checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'num');
+      } else {
+        checkDynamicTypeRef(typeRef.typeArguments[0]);
+      }
+    }
   }
 
   test_type_arguments_order() {
     EntityRef typeRef = serializeTypeText('Map<int, Object>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
         numTypeParameters: 2, numTypeArguments: 2);
-    expect(typeRef.typeArguments, hasLength(2));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
     checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'Object');
   }
 
   test_type_dynamic() {
     checkDynamicTypeRef(serializeTypeText('dynamic'));
   }
 
   test_type_param_codeRange() {
     UnlinkedClass cls =
@@ skipping 303 matching lines @@
 
   test_typedef_private() {
     serializeTypedefText('typedef _F();', '_F');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_typedef_reference_generic() {
     EntityRef typeRef =
         serializeTypeText('F', otherDeclarations: 'typedef void F<A, B>();');
     checkTypeRef(typeRef, null, null, 'F',
-        numTypeParameters: 2, expectedKind: ReferenceKind.typedef);
+        numTypeParameters: 2,
+        expectedKind: ReferenceKind.typedef,
+        numTypeArguments: elementMode ? 2 : 0);
+    if (elementMode) {
+      checkDynamicTypeRef(typeRef.typeArguments[0]);
+      checkDynamicTypeRef(typeRef.typeArguments[1]);
+    }
   }
 
   test_typedef_reference_generic_imported() {
     addNamedSource('/lib.dart', 'typedef void F<A, B>();');
     EntityRef typeRef =
         serializeTypeText('F', otherDeclarations: 'import "lib.dart";');
     checkTypeRef(typeRef, absUri('/lib.dart'), 'lib.dart', 'F',
-        numTypeParameters: 2, expectedKind: ReferenceKind.typedef);
+        numTypeParameters: 2,
+        expectedKind: ReferenceKind.typedef,
+        numTypeArguments: elementMode ? 2 : 0);
+    if (elementMode) {
+      checkDynamicTypeRef(typeRef.typeArguments[0]);
+      checkDynamicTypeRef(typeRef.typeArguments[1]);
+    }
   }
 
   test_typedef_return_type_explicit() {
     UnlinkedTypedef type = serializeTypedefText('typedef int F();');
     checkTypeRef(type.returnType, 'dart:core', 'dart:core', 'int');
   }
 
   test_typedef_type_param_in_parameter() {
     UnlinkedTypedef type = serializeTypedefText('typedef F<T>(T t);');
     checkParamTypeRef(type.parameters[0].type, 1);
@@ skipping 267 matching lines @@
         greaterThanOrEqualTo(unlinkedUnits[0].references.length));
   }
 
   test_variable_propagated_type_omit_dynamic() {
     if (skipFullyLinkedData) {
       return;
     }
     UnlinkedVariable v = serializeVariableText('final v = <int, dynamic>{};');
     EntityRef type = getTypeRefForSlot(v.propagatedTypeSlot);
     checkLinkedTypeRef(type, 'dart:core', 'dart:core', 'Map',
-        allowTypeArguments: true, numTypeParameters: 2);
-    expect(type.typeArguments, hasLength(1));
+        numTypeParameters: 2, numTypeArguments: 2);
     checkLinkedTypeRef(type.typeArguments[0], 'dart:core', 'dart:core', 'int');
+    checkLinkedDynamicTypeRef(type.typeArguments[1]);
   }
 
   test_variable_propagatedTypeSlot_const() {
     // Const variables are propagable so they have a nonzero
     // propagatedTypeSlot.
     UnlinkedVariable variable = serializeVariableText('const v = 0;');
     expect(variable.propagatedTypeSlot, isNot(0));
   }
 
   test_variable_propagatedTypeSlot_final() {
@@ skipping 190 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});
 }