Store return types of variable initializers in summaries.

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 143 matching lines @@
    */
   final List<_SerializeTypeRef> deferredLinkedTypes = <_SerializeTypeRef>[];
 
   /**
    * Index into the "references table" representing an unresolved reference, if
    * such an index exists.  `null` if no such entry has been made in the
    * references table yet.
    */
   int unresolvedReferenceIndex = null;
 
+  /**
+   * Index into the "references table" representing the "bottom" type, if such
+   * an index exists.  `null` if no such entry has been made in the references
+   * table yet.
+   */
+  int bottomReferenceIndex = null;
+
   _CompilationUnitSerializer(
       this.librarySerializer, this.compilationUnit, this.unitNum);
 
   /**
    * Add all classes, enums, typedefs, executables, and top level variables
    * from the given compilation unit [element] to the compilation unit summary.
    * [unitNum] indicates the ordinal position of this compilation unit in the
    * library.
    */
   void addCompilationUnitElements() {
@@ skipping 176 matching lines @@
       return const <UnlinkedConstBuilder>[];
     }
     return element.metadata.map((ElementAnnotationImpl a) {
       _ConstExprSerializer serializer = new _ConstExprSerializer(this, null);
       serializer.serializeAnnotation(a.annotationAst);
       return serializer.toBuilder();
     }).toList();
   }
 
   /**
+   * Return the index of the entry in the references table
+   * ([LinkedLibrary.references]) used for the "bottom" type.  A new entry is
+   * added to the table if necessary to satisfy the request.
+   */
+  int serializeBottomReference() {
+    if (bottomReferenceIndex == null) {
+      // References to the "bottom" type are always implicit, since there is no
+      // way to explicitly refer to the "bottom" type.  Therefore they should
+      // be stored only in the linked references table.
+      int index = linkedReferences.length;
+      linkedReferences.add(new LinkedReferenceBuilder(
+          name: '*bottom*', kind: ReferenceKind.classOrEnum));
+      return index;

[scheglov, 2016/02/18 18:11:44]

Also maybe remove this statement and fall through.
AFAIK this would be closer to the "lazy initialization" pattern.

[Paul Berry, 2016/02/18 18:18:15]

Good catch, thanks!  Fixed both here and in serializeUnresolvedReference(), and
I added tests which would have failed in the absence of these fixes.

+    }
+    return bottomReferenceIndex;
+  }
+
+  /**
    * Serialize the given [classElement], creating an [UnlinkedClass].
    */
   UnlinkedClassBuilder serializeClass(ClassElement classElement) {
     UnlinkedClassBuilder b = new UnlinkedClassBuilder();
     b.name = classElement.name;
     b.nameOffset = classElement.nameOffset;
     b.typeParameters =
         classElement.typeParameters.map(serializeTypeParam).toList();
     if (classElement.supertype == null) {
       b.hasNoSupertype = true;
@@ skipping 145 matching lines @@
   }
 
   /**
    * Serialize the given [executableElement], creating an [UnlinkedExecutable].
    */
   UnlinkedExecutableBuilder serializeExecutable(
       ExecutableElement executableElement) {
     UnlinkedExecutableBuilder b = new UnlinkedExecutableBuilder();
     b.name = executableElement.name;
     b.nameOffset = executableElement.nameOffset;
-    if (executableElement.enclosingElement is VariableElement) {
-      // TODO(scheglov) remove this check and serialize initializer types
-      // Note that for code like `var v = null` w need to support Bottom.
-    } else if (executableElement is! ConstructorElement) {
+    if (executableElement is! ConstructorElement) {
       if (!executableElement.hasImplicitReturnType) {
         b.returnType = serializeTypeRef(
             executableElement.type.returnType, executableElement);
       } else if (!executableElement.isStatic) {
         b.inferredReturnTypeSlot =
             storeInferredType(executableElement.returnType, executableElement);
       }
     }
     b.typeParameters =
         executableElement.typeParameters.map(serializeTypeParam).toList();
@@ skipping 192 matching lines @@
   /**
    * Compute the reference index which should be stored in a [EntityRef].
    *
    * If [linked] is true, and a new reference has to be created, the reference
    * will only be stored in [linkedReferences].
    */
   int serializeReferenceForType(DartType type, bool linked) {
     Element element = type.element;
     LibraryElement dependentLibrary = element?.library;
     if (dependentLibrary == null) {
+      if (type.isBottom) {
+        // References to the "bottom" type are always implicit, since there is
+        // no way to explicitly refer to the "bottom" type.  Therefore they
+        // should always be linked.
+        assert(linked);
+        return serializeBottomReference();
+      }
       assert(type.isDynamic || type.isVoid);
       if (type is UndefinedTypeImpl) {
         return serializeUnresolvedReference();
       }
       // Note: for a type which is truly `dynamic` or `void`, fall through to
       // use [_getElementReferenceId].
     }
     return _getElementReferenceId(element, linked: linked);
   }
 
@@ skipping 174 matching lines @@
     }
     // TODO(scheglov) VariableMember.initializer is not implemented
     if (variable is! VariableMember && variable.initializer != null) {
       b.initializer = serializeExecutable(variable.initializer);
     }
     return b;
   }
 
   /**
    * Create a slot id for the given [type] (which is an inferred type).  If
-   * strong mode is enabled and [type] is not `dynamic`, it is stored in
-   * [linkedTypes] so that once the compilation unit has been fully visited, it
-   * will be serialized into [LinkedUnit.types].
+   * [type] is not `dynamic`, it is stored in [linkedTypes] so that once the
+   * compilation unit has been fully visited, it will be serialized into
+   * [LinkedUnit.types].
    *
    * [context] is the element within which the slot id will appear; this is
    * used to serialize type parameters.
    */
   int storeInferredType(DartType type, Element context) {
-    return storeLinkedType(
-        librarySerializer.strongMode && !type.isDynamic ? type : null, context);
+    return storeLinkedType(type.isDynamic ? null : type, context);
   }
 
   /**
    * Create a slot id for the given [type] (which may be either a propagated
    * type or an inferred type).  If [type] is not `null`, it is stored in
    * [linkedTypes] so that once the compilation unit has been fully visited,
    * it will be serialized to [LinkedUnit.types].
    *
    * [context] is the element within which the slot id will appear; this is
    * used to serialize type parameters.
@@ skipping 408 matching lines @@
       exportNames.add(new LinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 }