Resynthesize constructor initializers from Kernel.

pkg/analyzer/lib/src/dart/element/element.dart

 // Copyright (c) 2014, 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.src.dart.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 2197 matching lines @@
       UnlinkedExecutable serializedExecutable, ClassElementImpl enclosingClass)
       : _kernelConstructor = null,
         _kernelFactory = null,
         super.forSerialized(serializedExecutable, enclosingClass);
 
   /**
    * Return the constant initializers for this element, which will be empty if
    * there are no initializers, or `null` if there was an error in the source.
    */
   List<ConstructorInitializer> get constantInitializers {
-    if (serializedExecutable != null && _constantInitializers == null) {
-      _constantInitializers ??= serializedExecutable.constantInitializers
-          .map((i) => _buildConstructorInitializer(i))
-          .toList(growable: false);
+    if (_constantInitializers == null) {
+      if (_kernelConstructor != null) {
+        var context = enclosingUnit._kernelContext;
+        _constantInitializers = _kernelConstructor.initializers
+            .map((k) => context.getConstructorInitializer(this, k))
+            .where((i) => i != null)
+            .toList();
+      }
+      if (serializedExecutable != null) {
+        _constantInitializers = serializedExecutable.constantInitializers
+            .map((i) => _buildConstructorInitializer(i))
+            .toList(growable: false);
+      }
     }
     return _constantInitializers;
   }
 
   void set constantInitializers(
       List<ConstructorInitializer> constantInitializers) {
     _assertNotResynthesized(serializedExecutable);
     _constantInitializers = constantInitializers;
   }
 
@@ skipping 110 matching lines @@
     return _periodOffset;
   }
 
   void set periodOffset(int periodOffset) {
     _assertNotResynthesized(serializedExecutable);
     _periodOffset = periodOffset;
   }
 
   @override
   ConstructorElement get redirectedConstructor {
-    if (serializedExecutable != null && _redirectedConstructor == null) {
-      if (serializedExecutable.isRedirectedConstructor) {
-        if (serializedExecutable.isFactory) {
-          _redirectedConstructor = enclosingUnit.resynthesizerContext
-              .resolveConstructorRef(
-                  enclosingElement, serializedExecutable.redirectedConstructor);
+    if (_redirectedConstructor == null) {
+      if (_kernelConstructor != null) {
+        for (var initializer in _kernelConstructor.initializers) {
+          if (initializer is kernel.RedirectingInitializer) {
+            return _redirectedConstructor = enclosingUnit._kernelContext
+                    .getElement(initializer.targetReference)
+                as ConstructorElementImpl;
+          }
+        }
+      }
+      if (serializedExecutable != null) {
+        if (serializedExecutable.isRedirectedConstructor) {
+          if (serializedExecutable.isFactory) {
+            _redirectedConstructor = enclosingUnit.resynthesizerContext
+                .resolveConstructorRef(enclosingElement,
+                    serializedExecutable.redirectedConstructor);
+          } else {
+            _redirectedConstructor = enclosingElement.getNamedConstructor(
+                serializedExecutable.redirectedConstructorName);
+          }
         } else {
-          _redirectedConstructor = enclosingElement.getNamedConstructor(
-              serializedExecutable.redirectedConstructorName);
+          return null;
         }
-      } else {
-        return null;
       }
     }
     return _redirectedConstructor;
   }
 
   void set redirectedConstructor(ConstructorElement redirectedConstructor) {
     _assertNotResynthesized(serializedExecutable);
     _redirectedConstructor = redirectedConstructor;
   }
 
@@ skipping 3484 matching lines @@
   }
 }
 
 /**
  * The kernel context in which a library is resynthesized.
  */
 abstract class KernelLibraryResynthesizerContext {
   kernel.Library get library;
 
   /**
+   * Return the resynthesized [ConstructorInitializer] for the given Kernel
+   * [initializer], or `null` if synthetic.
+   */
+  ConstructorInitializer getConstructorInitializer(
+      ConstructorElementImpl constructor, kernel.Initializer initializer);
+
+  /**
+   * Return the [Element] referenced by the given [reference].
+   */
+  ElementImpl getElement(kernel.Reference reference);
+
+  /**
    * Return the [Expression] for the given kernel.
    */
   Expression getExpression(kernel.Expression expression);
 
   /**
    * Return the [InterfaceType] for the given Kernel [type], or `null` if the
    * [type] does not correspond to an [InterfaceType].
    */
   InterfaceType getInterfaceType(ElementImpl context, kernel.Supertype type);
 
@@ skipping 3676 matching lines @@
 
   @override
   DartObject computeConstantValue() => null;
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     _initializer?.accept(visitor);
   }
 }