Resynthesize factory constructors 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 532 matching lines @@
     }
     return super.codeOffset;
   }
 
   @override
   List<ConstructorElement> get constructors {
     if (isMixinApplication) {
       return _computeMixinAppConstructors();
     }
     if (_kernel != null && _constructors == null) {
-      _constructors = _kernel.constructors
-          .map((k) => new ConstructorElementImpl.forKernel(this, k))
-          .toList(growable: false);
+      var constructors = _kernel.constructors
+          .map((k) => new ConstructorElementImpl.forKernel(this, k, null));
+      var factories = _kernel.procedures
+          .where((k) => k.isFactory)
+          .map((k) => new ConstructorElementImpl.forKernel(this, null, k));
+      _constructors = <ConstructorElement>[]
+        ..addAll(constructors)
+        ..addAll(factories);
     }
     if (_unlinkedClass != null && _constructors == null) {
       _constructors = _unlinkedClass.executables
           .where((e) => e.kind == UnlinkedExecutableKind.constructor)
           .map((e) => new ConstructorElementImpl.forSerialized(e, this))
           .toList(growable: false);
       // Ensure at least implicit default constructor.
       if (_constructors.isEmpty) {
         ConstructorElementImpl constructor = new ConstructorElementImpl('', -1);
         constructor.isSynthetic = true;
@@ skipping 1417 matching lines @@
 
   /**
    * The initializers for this constructor (used for evaluating constant
    * instance creation expressions).
    */
   List<ConstructorInitializer> _constantInitializers;
 
   /**
    * The kernel of the element.
    */
-  final kernel.Constructor _kernel;
+  final kernel.Constructor _kernelConstructor;

[Paul Berry, 2017/07/14 20:31:02]

It seems unfortunate to bloat the memory footprint of the element model just
because a constructor can take two different possible forms.  How about if
instead we just do:

final kernel.Member _kernel;

And use "is" checks to distinguish factory and non-factory constructors?

+
+  /**
+   * The kernel of the element.
+   */
+  final kernel.Procedure _kernelFactory;
 
   /**
    * The offset of the `.` before this constructor name or `null` if not named.
    */
   int _periodOffset;
 
   /**
    * Return the offset of the character immediately following the last character
    * of this constructor's name, or `null` if not named.
    */
   int _nameEnd;
 
   /**
    * True if this constructor has been found by constant evaluation to be free
    * of redirect cycles, and is thus safe to evaluate.
    */
   bool _isCycleFree = false;
 
   /**
    * Initialize a newly created constructor element to have the given [name] and
    * [offset].
    */
   ConstructorElementImpl(String name, int offset)
-      : _kernel = null,
+      : _kernelConstructor = null,
+        _kernelFactory = null,
         super(name, offset);
 
   /**
    * Initialize using the given serialized information.
    */
-  ConstructorElementImpl.forKernel(
-      ClassElementImpl enclosingClass, this._kernel)
-      : super.forKernel(enclosingClass, _kernel) {
-    isSynthetic = _kernel.isSyntheticDefault;
+  ConstructorElementImpl.forKernel(ClassElementImpl enclosingClass,
+      this._kernelConstructor, this._kernelFactory)
+      : super.forKernel(enclosingClass, _kernelConstructor ?? _kernelFactory) {
+    isSynthetic = _kernelConstructor?.isSyntheticDefault ?? false;
   }
 
   /**
    * Initialize a newly created constructor element to have the given [name].
    */
   ConstructorElementImpl.forNode(Identifier name)
-      : _kernel = null,
+      : _kernelConstructor = null,
+        _kernelFactory = null,
         super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   ConstructorElementImpl.forSerialized(
       UnlinkedExecutable serializedExecutable, ClassElementImpl enclosingClass)
-      : _kernel = null,
+      : _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))
@@ skipping 19 matching lines @@
   /**
    * Set whether this constructor represents a factory method.
    */
   void set factory(bool isFactory) {
     _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.FACTORY, isFactory);
   }
 
   @override
   bool get isConst {
-    if (_kernel != null) {
-      return _kernel.isConst;
+    if (_kernelConstructor != null) {
+      return _kernelConstructor.isConst;
+    }
+    if (_kernelFactory != null) {
+      return _kernelFactory.isConst;
     }
     if (serializedExecutable != null) {
       return serializedExecutable.isConst;
     }
     return hasModifier(Modifier.CONST);
   }
 
   /**
    * Set whether this constructor represents a 'const' constructor.
    */
@@ skipping 29 matching lines @@
       if (parameter.parameterKind == ParameterKind.REQUIRED) {
         return false;
       }
     }
     // OK, can be used as default constructor
     return true;
   }
 
   @override
   bool get isFactory {
+    if (_kernelConstructor != null) return false;
+    if (_kernelFactory != null) return true;
     if (serializedExecutable != null) {
       return serializedExecutable.isFactory;
     }
     return hasModifier(Modifier.FACTORY);
   }
 
   @override
   bool get isStatic => false;
 
   @override
@@ skipping 6858 matching lines @@
 
   @override
   DartObject computeConstantValue() => null;
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     _initializer?.accept(visitor);
   }
 }