Resynthesize factoring constructor redirects from Kernel.

pkg/analyzer/lib/src/kernel/resynthesize.dart

 // Copyright (c) 2017, 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.
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 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/type.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
 import 'package:front_end/src/base/source.dart';
+import 'package:front_end/src/fasta/kernel/redirecting_factory_body.dart';
 import 'package:kernel/kernel.dart' as kernel;
 import 'package:kernel/type_environment.dart' as kernel;
 
 /**
  * Object that can resynthesize analyzer [LibraryElement] from Kernel.
  */
 class KernelResynthesizer {
   final AnalysisContext _analysisContext;
   final kernel.TypeEnvironment _types;
   final Map<String, kernel.Library> _kernelMap;
@@ skipping 362 matching lines @@
       ConstructorElementImpl constructor, kernel.Initializer k) {
     if (k is kernel.LocalInitializer ||
         k is kernel.FieldInitializer && k.isSynthetic ||
         k is kernel.SuperInitializer && k.isSynthetic) {
       return null;
     }
     return new _ExprBuilder(this).buildInitializer(k);
   }
 
   @override
-  ElementImpl getElement(kernel.Reference reference) {
-    return _getElement(reference.canonicalName);
-  }
-
-  @override
   Expression getExpression(kernel.Expression expression) {
     return new _ExprBuilder(this).build(expression);
   }
 
   @override
   InterfaceType getInterfaceType(
       ElementImpl context, kernel.Supertype kernelType) {
     return _getInterfaceType(
         context, kernelType.className.canonicalName, kernelType.typeArguments);
   }
 
   @override
   LibraryElement getLibrary(String uriStr) {
     return _resynthesizer.getLibrary(uriStr);
   }
 
+  @override
+  ConstructorElementImpl getRedirectedConstructor(
+      kernel.Constructor kernelConstructor, kernel.Procedure kernelFactory) {
+    if (kernelConstructor != null) {
+      for (var initializer in kernelConstructor.initializers) {
+        if (initializer is kernel.RedirectingInitializer) {
+          return _getElement(initializer.targetReference.canonicalName)
+              as ConstructorElementImpl;
+        }
+      }
+    }
+    if (kernelFactory != null) {
+      kernel.Statement body = kernelFactory.function.body;
+      if (body is RedirectingFactoryBody) {
+        kernel.Member target = body.target;
+        if (target != null) {
+          return _getElement(target.reference.canonicalName)
+              as ConstructorElementImpl;
+        }
+      }
+    }
+    return null;
+  }
+
   DartType getType(ElementImpl context, kernel.DartType kernelType) {
     if (kernelType is kernel.DynamicType) return DynamicTypeImpl.instance;
     if (kernelType is kernel.VoidType) return VoidTypeImpl.instance;
 
     if (kernelType is kernel.InterfaceType) {
       return _getInterfaceType(context, kernelType.className.canonicalName,
           kernelType.typeArguments);
     }
 
     if (kernelType is kernel.TypeParameterType) {
@@ skipping 134 matching lines @@
         for (var typeParameter in ctx.typeParameters) {
           if (typeParameter.name == name) {
             return typeParameter;
           }
         }
       }
     }
     throw new StateError('Not found $kernelTypeParameter in $context');
   }
 }