anchor.diff:  
       if (constructor.initializers.isNotEmpty &&
           constructor.initializers.last is RedirectingInitializer) {
  -      var cont = new RedirectingConstructorInvocationApplication(newObject,
  -          constructor.initializers.last, ctrEnv, expressionContinuation);
  -      var es = _createLocalInitializerExpressionList(
  -          constructor.initializers.take(constructor.initializers.length - 1));
  -      return new ExpressionListConfiguration(es, ctrEnv, cont);
  -    }
  -
  +      // Constructor is redirecting.
  +      Initializer initializer = constructor.initializers.first;
  +      if (initializer is RedirectingInitializer) {
  +        var app = new ConstructorInvocationApplication(
  +            newObject, initializer.target, expressionContinuation);
  +        var args = _createArgumentExpressionList(
  +            initializer.arguments, initializer.target.function);
  +
  +        return new ExpressionListConfiguration(args, ctrEnv, app);
  +      }
  +      // Redirecting initializer is not the only initializer.
  +      for (Initializer i in constructor.initializers.reversed.skip(1)) {
  +        assert(i is LocalInitializer);
  +      }
  +      var class_ = new Class(constructor.enclosingClass.reference);
  +      var cont = new InitializerContinuation(newObject, class_, ctrEnv,
  +          constructor.initializers, expressionContinuation);
  +      return new ExpressionConfiguration(
  +          (initializer as LocalInitializer).variable.initializer, ctrEnv, cont);
  +    }
  +
  +    // Initialize fields in immediately enclosing class.
       var cont = new InstanceFieldsApplication(
           newObject, constructor, ctrEnv, expressionContinuation);
       var fieldExpressions = _createInstanceInitializers(constructor);
   
       return new ExpressionListConfiguration(fieldExpressions, ctrEnv, cont);
  -  }
  -
  -  /// Creates a list of expressions for local initializers.
  -  static List<InterpreterExpression> _createLocalInitializerExpressionList(
  -      List<LocalInitializer> initializers) {
  -    List<InterpreterExpression> es = <InterpreterExpression>[];
  -
  -    for (int i = 0; i < initializers.length; i++) {
  -      var current = initializers[i];
  -      es.add(new LocalInitializerExpression(current.variable));
  -    }
  -    return es;
     }
   
     /// Creates a list of expressions for instance field initializers in
  
positive.code:       _currentClass.setProperty(newObject, current.field, current.value);
      }
  
      var es = _createInitializerListExpressions(constructor.initializers);
      List<Initializer> initializers = constructor.initializers.skip(es.length);
  
      ApplicationContinuation cont = new InitializerListApplication(newObject,
          constructor, environment, initializers, expressionContinuation);
  
      return new ExpressionListConfiguration(es, environment, cont);
    }
  }
  
  /// Represents the application continuation applied on the list of evaluated
  /// initializer expressions preceding a super call in the list.
  class InitializerListApplication extends ApplicationContinuation {
    final ObjectValue newObject;
    final Constructor constructor;
    final Environment environment;
    final List<Initializer> remainingInitializers;
    final ExpressionContinuation expressionContinuation;
  
    final Class _currentClass;
  
    InitializerListApplication(this.newObject, this.constructor, this.environment,
        this.remainingInitializers, this.expressionContinuation)
        : _currentClass = new Class(constructor.enclosingClass.reference);
  
    Configuration call(List<InterpreterValue> values) {
      var initEnv = new Environment(environment);
  
      // Apply values from evaluation to object or/and initializer environment.
      for (InterpreterValue current in values.reversed) {
        if (current is LocalInitializerValue) {
          initEnv.expand(current.variable, current.value);
        } else if (current is FieldInitializerValue) {
          _currentClass.setProperty(newObject, current.field, current.value);
        } else {
          throw '${current.runtimeType} in InitializerListApplication';
        }
      }
  
      if (remainingInitializers.isNotEmpty) {
        assert(remainingInitializers.first is SuperInitializer);
        // todo: Evaluate arguments for super invocation.
      }
  
      return new ContinuationConfiguration(expressionContinuation, newObject);
    }
  }
  
  
negative.code: }
  
  /// Represents the application continuation applied on the list of evaluated
  /// field initializer expressions.
  class InstanceFieldsApplication extends ApplicationContinuation {
    final ObjectValue newObject;
  