Properly handle forwarding factory constructors in type inference.

sdk/lib/_internal/compiler/implementation/inferrer/simple_types_inferrer.dart

 // Copyright (c) 2013, 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 simple_types_inferrer;
 
 import '../closure.dart' show ClosureClassMap, ClosureScope;
 import '../dart_types.dart'
     show DartType, InterfaceType, FunctionType, TypeKind;
 import '../elements/elements.dart';
@@ skipping 961 matching lines @@
     }
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     if (visitingInitializers) {
       if (ast.Initializers.isConstructorRedirect(node)) {
         isConstructorRedirect = true;
       } else if (ast.Initializers.isSuperConstructorCall(node)) {
         seenSuperConstructorCall = true;
         analyzeSuperConstructorCall(element, arguments);
       }
     }
+    // If we are looking at a new expression on a forwarding factory,
+    // we have to forward the call to the effective target of the
+    // factory.
+    if (element.isFactoryConstructor) {
+      ConstructorElement constructor = element;
+      if (constructor.isRedirectingFactory) {
+        element = constructor.effectiveTarget.implementation;
+      }
+    }
     if (element.isForeign(compiler.backend)) {
       return handleForeignSend(node);
     }
     Selector selector = elements.getSelector(node);
     // In erroneous code the number of arguments in the selector might not
     // match the function element.
     // TODO(polux): return nonNullEmpty and check it doesn't break anything
     if (!selector.applies(element, compiler.world)) return types.dynamicType;
 
     T returnType = handleStaticSend(node, selector, element, arguments);
@@ skipping 116 matching lines @@
       return inferrer.registerCalledClosure(
           node, selector, closure, outermostElement, arguments,
           sideEffects, inLoop);
     }
   }
 
   T handleStaticSend(ast.Node node,
                      Selector selector,
                      Element element,
                      ArgumentsTypes arguments) {
+    assert(!element.isFactoryConstructor ||
+           !(element as ConstructorElement).isRedirectingFactory);
     // Erroneous elements may be unresolved, for example missing getters.
     if (Elements.isUnresolved(element)) return types.dynamicType;
     // TODO(herhut): should we follow redirecting constructors here? We would
     // need to pay attention of the constructor is pointing to an erroneous
     // element.
     return inferrer.registerCalledElement(
         node, selector, outermostElement, element, arguments,
         sideEffects, inLoop);
   }
 
@@ skipping 160 matching lines @@
     }
 
     handlePlainAssignment(identifier, element, selector,
                           receiverType, currentType,
                           node.expression);
     return handleLoop(node, () {
       visit(node.body);
     });
   }
 }