Store FunctionType(s) of local functions by value.

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/error/listener.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
@@ skipping 471 matching lines @@
    * explicit reference.  If the type reference in question is an implicit
    * reference, return `null`.
    */
   UnlinkedReference checkReferenceIndex(
       int referenceIndex, String absoluteUri, String expectedName,
       {ReferenceKind expectedKind: ReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
       LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
       int numTypeParameters: 0,
-      int localIndex: 0,
       bool unresolvedHasName: false}) {
     linkedSourceUnit ??= definingUnit;
     unlinkedSourceUnit ??= unlinkedUnits[0];
     LinkedReference referenceResolution =
         linkedSourceUnit.references[referenceIndex];
     String name;
     UnlinkedReference reference;
     if (referenceIndex < unlinkedSourceUnit.references.length) {
       // This is an explicit reference, so its name and prefix should be in
       // [UnlinkedUnit.references].
@@ skipping 18 matching lines @@
       checkDependency(referenceResolution.dependency, absoluteUri);
     }
     if (expectedName == null) {
       expect(name, isEmpty);
     } else {
       expect(name, expectedName);
     }
     expect(referenceResolution.kind, expectedKind);
     expect(referenceResolution.unit, expectedTargetUnit);
     expect(referenceResolution.numTypeParameters, numTypeParameters);
-    expect(referenceResolution.localIndex, localIndex);
     return reference;
   }
 
   /**
    * Verify that the given [typeRef] represents a reference to a type declared
    * in a file reachable via [absoluteUri], having name [expectedName].
    * If [expectedPrefix] is supplied, verify that the type is reached via the
    * given prefix.  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
@@ skipping 1023 matching lines @@
 }
 ''');
     expect(executable.localFunctions, hasLength(2));
     EntityRef closureType =
         getTypeRefForSlot(executable.localFunctions[1].inferredReturnTypeSlot);
     checkLinkedTypeRef(closureType, null, '',
         expectedKind: ReferenceKind.function);
     int outerClosureIndex =
         definingUnit.references[closureType.reference].containingReference;
     checkReferenceIndex(outerClosureIndex, null, '',
-        expectedKind: ReferenceKind.function, localIndex: 1);
+        expectedKind: ReferenceKind.function);
     int topLevelFunctionIndex =
         definingUnit.references[outerClosureIndex].containingReference;
     checkReferenceIndex(topLevelFunctionIndex, null, 'f',
         expectedKind: ReferenceKind.topLevelFunction);
     expect(
         definingUnit.references[topLevelFunctionIndex].containingReference, 0);
   }
 
   test_closure_executable_with_unimported_return_type() {
     addNamedSource('/a.dart', 'import "b.dart"; class C { D d; }');
@@ skipping 7674 matching lines @@
     // Element zero of the references table should be populated in a standard
     // way.
     serializeLibraryText('');
     UnlinkedReference unlinkedReference0 = unlinkedUnits[0].references[0];
     expect(unlinkedReference0.name, '');
     expect(unlinkedReference0.prefixReference, 0);
     LinkedReference linkedReference0 = linked.units[0].references[0];
     expect(linkedReference0.containingReference, 0);
     expect(linkedReference0.dependency, 0);
     expect(linkedReference0.kind, ReferenceKind.unresolved);
-    expect(linkedReference0.localIndex, 0);
     expect(linkedReference0.name, '');
     expect(linkedReference0.numTypeParameters, 0);
     expect(linkedReference0.unit, 0);
   }
 
   test_setter_documented() {
     if (!includeInformative) return;
     String text = '''
 // Extra comment so doc comment offset != 0
 /**
@@ skipping 1018 matching lines @@
  */
 class _PrefixExpectation {
   final ReferenceKind kind;
   final String name;
   final String absoluteUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
       {this.absoluteUri, this.numTypeParameters: 0});
 }