Allow linked types to refer to local executables.

pkg/analyzer/lib/src/summary/summarize_elements.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 serialization.elements;
 
 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/dart/element/member.dart';
@@ skipping 33 matching lines @@
     return ReferenceKind.function;
   } else if (element is FunctionTypeAliasElement) {
     return ReferenceKind.typedef;
   } else if (element is PropertyAccessorElement) {
     if (element.enclosingElement is ClassElement) {
       return ReferenceKind.propertyAccessor;
     }
     return ReferenceKind.topLevelPropertyAccessor;
   } else if (element is MethodElement) {
     return ReferenceKind.method;
+  } else if (element is TopLevelVariableElement) {
+    // Summaries don't need to distinguish between references to a variable and
+    // references to its getter.
+    return ReferenceKind.topLevelPropertyAccessor;
+  } else if (element is LocalVariableElement) {
+    return ReferenceKind.variable;
+  } else if (element is FieldElement) {
+    // Summaries don't need to distinguish between references to a field and
+    // references to its getter.
+    return ReferenceKind.propertyAccessor;
   } else {
     throw new Exception('Unexpected element kind: ${element.runtimeType}');
   }
 }
 
 /**
  * Type of closures used by [_LibrarySerializer] to defer generation of
  * [EntityRefBuilder] objects until the end of serialization of a
  * compilation unit.
  */
@@ skipping 938 matching lines @@
         }
       }
       ReferenceKind kind = _getReferenceKind(element);
       String name = element == null ? 'void' : element.name;
       int index;
       LinkedReferenceBuilder linkedReference;
       if (linked) {
         linkedReference =
             new LinkedReferenceBuilder(kind: kind, unit: unit, name: name);
         Element enclosing = element?.enclosingElement;
-        if (enclosing is ClassElement) {
+        if (enclosing != null && enclosing is! CompilationUnitElement) {
           linkedReference.containingReference =
               _getElementReferenceId(enclosing, linked: linked);
-          linkedReference.numTypeParameters = enclosing.typeParameters.length;
+          if (enclosing is ClassElement) {
+            linkedReference.numTypeParameters = enclosing.typeParameters.length;
+          } else if (enclosing is ExecutableElement) {
+            if (element is FunctionElement) {
+              assert(enclosing.functions.contains(element));
+              linkedReference.localIndex = enclosing.functions.indexOf(element);
+            } else if (element is LocalVariableElement) {
+              assert(enclosing.localVariables.contains(element));
+              linkedReference.localIndex =
+                  enclosing.localVariables.indexOf(element);
+            } else {
+              throw new StateError(
+                  'Unexpected enclosed element type: ${element.runtimeType}');
+            }
+          } else if (enclosing is VariableElement) {
+            assert(identical(enclosing.initializer, element));
+          } else {
+            throw new StateError(
+                'Unexpected enclosing element type: ${enclosing.runtimeType}');
+          }
         }
         index = linkedReferences.length;
         linkedReferences.add(linkedReference);
       } else {
         assert(unlinkedReferences.length == linkedReferences.length);
         int prefixReference = 0;
         Element enclosing = element?.enclosingElement;
         if (enclosing == null || enclosing is CompilationUnitElement) {
           // Figure out a prefix that may be used to refer to the given element.
           // TODO(paulberry): to avoid subtle relinking inconsistencies we
@@ skipping 357 matching lines @@
       exportNames.add(new LinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 }