Store FunctionType(s) of local functions by value.

pkg/analyzer/test/src/summary/resynthesize_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 test.src.serialization.elements_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 664 matching lines @@
           reason: desc);
     }
     expect(resynthesized.compilationUnit, isNotNull, reason: desc);
     expect(resynthesized.compilationUnit.location,
         original.compilationUnit.location,
         reason: desc);
     expect(resynthesized.annotationAst, isNotNull, reason: desc);
     compareConstAsts(resynthesized.annotationAst, original.annotationAst, desc);
   }
 
+  void compareElementLocations(
+      Element resynthesized, Element original, String desc) {
+    bool hasFunctionElementByValue(Element e) {
+      if (e == null) {
+        return false;
+      }
+      if (e is FunctionElementImpl_forLUB) {
+        return true;
+      }
+      return hasFunctionElementByValue(e.enclosingElement);
+    }
+
+    if (hasFunctionElementByValue(resynthesized)) {
+      // We resynthesize elements representing types of local functions
+      // without corresponding name offsets, so their locations don't have
+      // corresponding valid @offset components. Also, we don't put
+      // resynthesized local functions into initializers of variables.
+      return;
+    }
+    expect(resynthesized.location, original.location, reason: desc);
+  }
+
   void compareElements(Element resynthesized, Element original, String desc) {
     ElementImpl rImpl = getActualElement(resynthesized, desc);
     ElementImpl oImpl = getActualElement(original, desc);
     if (oImpl == null && rImpl == null) {
       return;
     }
     if (oImpl is PrefixElement) {
       // TODO(scheglov) prefixes cannot be resynthesized
       return;
     }
     expect(original, isNotNull);
     expect(resynthesized, isNotNull, reason: desc);
     if (rImpl is DefaultParameterElementImpl && oImpl is ParameterElementImpl) {
       // This is ok provided the resynthesized parameter element doesn't have
       // any evaluation result.
       expect(rImpl.evaluationResult, isNull);
     } else {
       Type rRuntimeType;
       if (rImpl is ConstFieldElementImpl) {
         rRuntimeType = ConstFieldElementImpl;
       } else if (rImpl is FunctionElementImpl) {
         rRuntimeType = FunctionElementImpl;
       } else {
         rRuntimeType = rImpl.runtimeType;
       }
       expect(rRuntimeType, oImpl.runtimeType);
     }
     expect(resynthesized.kind, original.kind);
-    expect(resynthesized.location, original.location, reason: desc);
+    compareElementLocations(resynthesized, original, desc);
     expect(resynthesized.name, original.name);
     expect(resynthesized.nameOffset, original.nameOffset,
         reason: '$desc.nameOffset');
     expect(rImpl.codeOffset, oImpl.codeOffset, reason: desc);
     expect(rImpl.codeLength, oImpl.codeLength, reason: desc);
     expect(resynthesized.documentationComment, original.documentationComment,
         reason: desc);
     compareMetadata(resynthesized.metadata, original.metadata, desc);
 
     // Validate modifiers.
@@ skipping 299 matching lines @@
 
   void compareTopLevelVariableElements(
       TopLevelVariableElementImpl resynthesized,
       TopLevelVariableElementImpl original,
       String desc) {
     comparePropertyInducingElements(resynthesized, original, desc);
   }
 
   void compareTypeImpls(
       TypeImpl resynthesized, TypeImpl original, String desc) {
-    expect(resynthesized.element.location, original.element.location,
-        reason: '$desc.element.location');
+    compareElementLocations(
+        resynthesized.element, original.element, '$desc.element.location');
     expect(resynthesized.name, original.name, reason: '$desc.name');
   }
 
   void compareTypeParameterElementLists(
       List<TypeParameterElement> resynthesized,
       List<TypeParameterElement> original,
       String desc) {
     int length = original.length;
     expect(resynthesized.length, length, reason: '$desc.length');
     for (int i = 0; i < length; i++) {
@@ skipping 2110 matching lines @@
     } else {
       checkElementText(
           library,
           r'''
 dynamic f() {}
 ''');
     }
   }
 
   test_closure_generic() {
-    var library = checkLibrary('final f = <U, V>(U x, V y) => y;');
+    var library = checkLibrary('final f = <U, V extends int>(U x, V y) => y;');
     if (isStrongMode) {
       checkElementText(
           library,
           r'''
-final <U,V>(U, V) → V f;
+final <U,V extends int>(U, V) → V f;
 ''');
     } else {
       checkElementText(
           library,
           r'''
 final dynamic f;
 ''');
     }
   }
 
@@ skipping 11983 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }