anchor.diff:      _resolveRedirectingFactoryTargets();
     }
   
  +  /// Return an [Expression] resolving the argument invocation.
  +  ///
  +  /// The arguments specify the [StaticInvocation] whose `.target` is
  +  /// [target], `.arguments` is [arguments], `.fileOffset` is [fileOffset],
  +  /// and `.isConst` is [isConst].
  +  Expression _resolveRedirectingFactoryTarget(
  +      Procedure target, Arguments arguments, int fileOffset, bool isConst) {
  +    Procedure initialTarget = target;
  +    Expression replacementNode;
  +
  +    RedirectionTarget redirectionTarget =
  +        getRedirectionTarget(initialTarget, this);
  +    Member resolvedTarget = redirectionTarget?.target;
  +
  +    if (resolvedTarget == null) {
  +      String name = constructorNameForDiagnostics(initialTarget.name.text,
  +          className: initialTarget.enclosingClass.name);
  +      // TODO(dmitryas): Report this error earlier.
  +      replacementNode = buildProblem(
  +          fasta.templateCyclicRedirectingFactoryConstructors
  +              .withArguments(name),
  +          initialTarget.fileOffset,
  +          name.length);
  +    } else if (resolvedTarget is Constructor &&
  +        resolvedTarget.enclosingClass.isAbstract) {
  +      replacementNode = evaluateArgumentsBefore(
  +          forest.createArguments(noLocation, arguments.positional,
  +              types: arguments.types, named: arguments.named),
  +          buildAbstractClassInstantiationError(
  +              fasta.templateAbstractRedirectedClassInstantiation
  +                  .withArguments(resolvedTarget.enclosingClass.name),
  +              resolvedTarget.enclosingClass.name,
  +              initialTarget.fileOffset));
  +    } else {
  +      RedirectingFactoryBody redirectingFactoryBody =
  +          getRedirectingFactoryBody(resolvedTarget);
  +      if (redirectingFactoryBody != null) {
  +        // If the redirection target is itself a redirecting factory, it means
  +        // that it is unresolved.
  +        assert(redirectingFactoryBody.isUnresolved);
  +        String errorName = redirectingFactoryBody.unresolvedName;
  +        replacementNode = buildProblem(
  +            fasta.templateMethodNotFound.withArguments(errorName),
  +            fileOffset,
  +            noLength,
  +            suppressMessage: true);
  +      } else {
  +        Substitution substitution = Substitution.fromPairs(
  +            initialTarget.function.typeParameters, arguments.types);
  +        arguments.types.clear();
  +        arguments.types.length = redirectionTarget.typeArguments.length;
  +        for (int i = 0; i < arguments.types.length; i++) {
  +          arguments.types[i] =
  +              substitution.substituteType(redirectionTarget.typeArguments[i]);
  +        }
  +
  +        replacementNode = buildStaticInvocation(
  +            resolvedTarget,
  +            forest.createArguments(noLocation, arguments.positional,
  +                types: arguments.types, named: arguments.named),
  +            constness:
  +                isConst ? Constness.explicitConst : Constness.explicitNew,
  +            charOffset: fileOffset);
  +      }
  +    }
  +    return replacementNode;
  +  }
  +
     void _resolveRedirectingFactoryTargets() {
       for (StaticInvocation invocation in redirectingFactoryInvocations) {
         // If the invocation was invalid, it or its parent has already been
  
positive.code:       if (unaliasedType is InterfaceType) {
          invocationTypeArguments = unaliasedType.typeArguments;
        }
        Arguments invocationArguments = new ArgumentsImpl(
            invocation.arguments.positional,
            types: invocationTypeArguments,
            named: invocation.arguments.named);
        invocation.replaceWith(new ConstructorInvocation(
            invocation.target, invocationArguments,
            isConst: invocation.isConst));
  
negative.code:   }
  
    void _unaliasTypeAliasedFactoryInvocations() {
      for (TypeAliasedFactoryInvocationJudgment invocation
          in typeAliasedFactoryInvocations) {
        DartType unaliasedType = new TypedefType(
                invocation.typeAliasBuilder.typedef,
                Nullability.nonNullable,
                invocation.arguments.types)
            .unalias;
        List<DartType> invocationTypeArguments = null;
        if (unaliasedType is InterfaceType) {
          invocationTypeArguments = unaliasedType.typeArguments;
        }
        Arguments invocationArguments = forest.createArguments(
            noLocation, invocation.arguments.positional,
            types: invocationTypeArguments, named: invocation.arguments.named);
        invocation.replaceWith(_resolveRedirectingFactoryTarget(invocation.target,
            invocationArguments, invocation.fileOffset, invocation.isConst));
      }
      typeAliasedFactoryInvocations.clear();
    }
  