Option to include redirecting factories.

pkg/kernel/lib/analyzer/ast_from_analyzer.dart

 // Copyright (c) 2016, 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 kernel.analyzer.ast_from_analyzer;
 
 import '../ast.dart' as ast;
 import '../frontend/accessors.dart';
 import '../frontend/super_initializers.dart';
 import '../log.dart';
 import '../type_algebra.dart';
@@ skipping 2334 matching lines @@
   void _buildMemberBody(ast.Member member, Element element, AstNode node) {
     new MemberBodyBuilder(scope.loader, member, element).build(node);
   }
 
   /// True if the given class member should not be emitted, and does not
   /// correspond to any Kernel member.
   ///
   /// This is true for redirecting factories with a resolved target. These are
   /// always bypassed at the call site.
   bool _isIgnoredMember(ClassMember node) {
-    return node is ConstructorDeclaration &&
-        node.factoryKeyword != null &&
-        resolutionMap
-                .elementDeclaredByConstructorDeclaration(node)
-                .redirectedConstructor !=
-            null;
+    if (node is ConstructorDeclaration && node.factoryKeyword != null) {
+      var element = resolutionMap.elementDeclaredByConstructorDeclaration(node);
+      return element.redirectedConstructor != null &&
+          (element.isSynthetic || scope.loader.ignoreRedirectingFactories);
+    } else {
+      return false;
+    }
   }
 
   visitClassDeclaration(ClassDeclaration node) {
     addAnnotations(node.metadata);
     ast.Class classNode = currentClass;
     assert(classNode.members.isEmpty); // All members will be added here.
 
     bool foundConstructor = false;
     for (var member in node.members) {
       if (_isIgnoredMember(member)) continue;
@@ skipping 295 matching lines @@
             classNode,
             types.freshTypeParameters
                 .map(makeTypeParameterType)
                 .toList(growable: false));
     var function = scope.buildFunctionNode(node.parameters, node.body,
         typeParameters: types.freshTypeParameters,
         inferredReturnType: inferredReturnType);
     procedure.function = function..parent = procedure;
     handleNativeBody(node.body);
     if (node.redirectedConstructor != null) {
-      // Redirecting factories with resolved targets don't show up here.
-      assert(resolutionMap
-              .elementDeclaredByConstructorDeclaration(node)
-              .redirectedConstructor ==
-          null);
+      // Add a new synthetic field to [classNode] for representing factory
+      // constructors. This is used by the new frontend engine to support
+      // resolving source code.
+      //
+      // The synthetic field looks like this:
+      //
+      //     final _redirecting# = [c1, ..., cn];
+      //
+      // Where each c1 ... cn are an instance of [StaticGet] whose target is
+      // the redirecting factory created above. The new frontend engine reads
+      // this field and rewrites them.
+      //
+      // TODO(ahe): Generate the correct factory body instead. This requires
+      // access to default values from other files, we'll probably never do
+      // that in this file, and instead rely on the new compiler for this.
+      var element = resolutionMap.elementDeclaredByConstructorDeclaration(node);
+      assert(!element.isSynthetic);
+      var expression;
+      if (node.element.redirectedConstructor != null) {
+        assert(!scope.loader.ignoreRedirectingFactories);
+        ConstructorElement element = node.element.redirectedConstructor;
+        while (element.isFactory && element.redirectedConstructor != null) {
+          element = element.redirectedConstructor;
+        }
+        ast.Member target = scope.getMemberReference(element);
+        assert(target != null);
+        expression = new ast.Let(
+            new ast.VariableDeclaration.forValue(new ast.StaticGet(target)),
+            new ast.InvalidExpression());
+        ast.Name constructors =
+            new ast.Name("_redirecting#", scope.currentLibrary);
+        ast.Field constructorsField;
+        for (ast.Field field in classNode.fields) {
+          if (field.name == constructors) {
+            constructorsField = field;
+            break;
+          }
+        }
+        if (constructorsField == null) {
+          ast.ListLiteral literal = new ast.ListLiteral(<ast.Expression>[]);
+          constructorsField = new ast.Field(constructors, isStatic: true,
+              initializer: literal, fileUri: classNode.fileUri)
+              ..fileOffset = classNode.fileOffset;
+          classNode.addMember(constructorsField);
+        }
+        ast.ListLiteral literal = constructorsField.initializer;
+        literal.expressions.add(new ast.StaticGet(procedure)..parent = literal);
+      } else {
+        var name = node.redirectedConstructor.type.name.name;
+        if (node.redirectedConstructor.name != null) {
+          name += '.' + node.redirectedConstructor.name.name;
+        }
+        // TODO(asgerf): Sometimes a TypeError should be thrown.
+        expression = scope.buildThrowNoSuchMethodError(
+            new ast.NullLiteral(), name, new ast.Arguments.empty());
+      }
       var function = procedure.function;
-      var name = node.redirectedConstructor.type.name.name;
-      if (node.redirectedConstructor.name != null) {
-        name += '.' + node.redirectedConstructor.name.name;
-      }
-      // TODO(asgerf): Sometimes a TypeError should be thrown.
-      function.body = new ast.ExpressionStatement(
-          scope.buildThrowNoSuchMethodError(
-              new ast.NullLiteral(), name, new ast.Arguments.empty()))
-        ..parent = function;
+      function.body = new ast.ExpressionStatement(expression)
+          ..parent = function;
     }
   }
 
   visitMethodDeclaration(MethodDeclaration node) {
     addAnnotations(node.metadata);
     ast.Procedure procedure = currentMember;
     procedure.function = scope.buildFunctionNode(node.parameters, node.body,
         returnType: node.returnType,
         inferredReturnType: scope.buildType(
             resolutionMap.elementDeclaredByMethodDeclaration(node).returnType),
@@ skipping 143 matching lines @@
     if (list[i - 1].compareTo(item) == 0) {
       ++deleted;
     } else if (deleted > 0) {
       list[i - deleted] = item;
     }
   }
   if (deleted > 0) {
     list.length -= deleted;
   }
 }