Issue 28547. Fix for summarizing code with invalid type parameter reference.

pkg/analyzer/lib/src/summary/summarize_ast.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 serialization.summarize_ast;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/type.dart' show DartType;
@@ skipping 81 matching lines @@
     } else {
       localIndex = localClosureIndexMap[functionExpression.offset];
       assert(localIndex != null);
       return <int>[0, localIndex];
     }
   }
 
   EntityRefBuilder serializeIdentifier(Identifier identifier) {
     EntityRefBuilder b = new EntityRefBuilder();
     if (identifier is SimpleIdentifier) {
-      int index = visitor.serializeSimpleReference(identifier.name,
-          allowTypeParameter: true);
+      int index = visitor.serializeSimpleReference(identifier.name);
       if (index < 0) {
         b.paramReference = -index;
       } else {
         b.reference = index;
       }
     } else if (identifier is PrefixedIdentifier) {
       int prefix = visitor.serializeSimpleReference(identifier.prefix.name);
       b.reference =

[Paul Berry, 2017/01/30 20:54:52]

Need to add error handling code here in case serializeSimpleReference returns a
negative value.

And also add a test case to validate it.

[scheglov, 2017/01/30 21:29:39]

Done.

           visitor.serializeReference(prefix, identifier.identifier.name);
     } else {
       throw new StateError(
           'Unexpected identifier type: ${identifier.runtimeType}');
     }
     return b;
   }
 
   @override
   EntityRefBuilder serializeIdentifierSequence(Expression expr) {
@@ skipping 137 matching lines @@
    */
   final List<UnlinkedImportBuilder> unlinkedImports = <UnlinkedImportBuilder>[];
 
   /**
    * The unlinked portion of the "references table".  This is the list of
    * objects which should be written to [UnlinkedUnit.references].
    */
   final List<UnlinkedReferenceBuilder> unlinkedReferences =
       <UnlinkedReferenceBuilder>[new UnlinkedReferenceBuilder()];
 
-
   /**
    * List of [_Scope]s currently in effect.  This is used to resolve type names
    * to type parameters within classes, typedefs, and executables, as well as
    * references to class members.
    */
   final List<_Scope> scopes = <_Scope>[];
 
   /**
    * True if 'dart:core' has been explicitly imported.
    */
@@ skipping 555 matching lines @@
         int index = unlinkedReferences.length;
         unlinkedReferences.add(new UnlinkedReferenceBuilder(
             prefixReference: prefixIndex, name: name));
         return index;
       });
 
   /**
    * Serialize a reference to a name declared either at top level or in a
    * nested scope.
    *
-   * If [allowTypeParameter] is `true`, then references to type
-   * parameters are allowed, and are returned as negative numbers.
+   * References to type parameters are returned as negative numbers.
    */
-  int serializeSimpleReference(String name, {bool allowTypeParameter: false}) {
+  int serializeSimpleReference(String name) {
     int indexOffset = 0;
     for (int i = scopes.length - 1; i >= 0; i--) {
       _Scope scope = scopes[i];
       _ScopedEntity entity = scope[name];
       if (entity != null) {
         if (entity is _ScopedClassMember) {
           return serializeReference(
               serializeReference(null, entity.className), name);
-        } else if (allowTypeParameter && entity is _ScopedTypeParameter) {
+        } else if (entity is _ScopedTypeParameter) {
           int paramReference = indexOffset + entity.index;
           return -paramReference;
-        } else {
-          // Invalid reference to a type parameter.  Should never happen in
-          // legal Dart code.
-          // TODO(paulberry): could this exception ever be uncaught in illegal
-          // code?
-          throw new StateError('Invalid identifier reference');
         }
       }
       if (scope is _TypeParameterScope) {
         indexOffset += scope.length;
       }
     }
     return serializeReference(null, name);
   }
 
   /**
@@ skipping 26 matching lines @@
               return b;
             }
           }
           if (scope is _TypeParameterScope) {
             indexOffset += scope.length;
           }
         }
         b.reference = serializeReference(null, name);
       } else if (identifier is PrefixedIdentifier) {
         int prefixIndex = serializeSimpleReference(identifier.prefix.name);
-        b.reference =
-            serializeReference(prefixIndex, identifier.identifier.name);
+        if (prefixIndex < 0) {
+          // Type parameters are not expected here, so this is an error and the
+          // type should be treated as a reference to `dynamic`.
+          b.reference = serializeReference(null, 'dynamic');
+          return b;
+        } else {
+          b.reference =
+              serializeReference(prefixIndex, identifier.identifier.name);
+        }
       } else {
         throw new StateError(
             'Unexpected identifier type: ${identifier.runtimeType}');
       }
       if (typeArguments != null) {
         b.typeArguments =
             typeArguments.arguments.map(serializeTypeName).toList();
       }
       return b;
     }
@@ skipping 490 matching lines @@
 /**
  * A [_TypeParameterScope] is a [_Scope] which defines [_ScopedTypeParameter]s.
  */
 class _TypeParameterScope extends _Scope {
   /**
    * Get the number of [_ScopedTypeParameter]s defined in this
    * [_TypeParameterScope].
    */
   int get length => _definedNames.length;
 }