anchor.diff:        _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
  +    if (constructor.initializers.isEmpty ||
  +        constructor.initializers.first is SuperInitializer) {
  +      // todo: eval super args or constructor body configuration.
  +      return new ContinuationConfiguration(expressionContinuation, newObject);
  +    }
  +
  +    Class class_ = new Class(constructor.enclosingClass.reference);
  +    Environment initEnv = new Environment(environment);
  +
  +    var cont = new InitializerContinuation(newObject, class_, initEnv,
  +        constructor.initializers, expressionContinuation);
  +    return new ExpressionConfiguration(
  +        _getExpression(constructor.initializers.first), initEnv, cont);
  +  }
  +}
  +
  +/// Represents the expression continuation applied on the list of evaluated
   /// initializer expressions preceding a super call in the list.
  -class InitializerListApplication extends ApplicationContinuation {
  +class InitializerContinuation extends ExpressionContinuation {
     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';
  +  final Class currentClass;
  +  final Environment initializerEnvironment;
  +  final List<Initializer> initializers;
  +  final ExpressionContinuation continuation;
  +
  +  InitializerContinuation(this.newObject, this.currentClass,
  +      this.initializerEnvironment, this.initializers, this.continuation);
  +
  +  Configuration call(Value v) {
  +    Initializer current = initializers.first;
  +    if (current is FieldInitializer) {
  +      currentClass.setProperty(newObject, current.field, v);
  +    } else if (current is LocalInitializer) {
  +      initializerEnvironment.expand(current.variable, v);
  +    } else {
  +      throw 'Assigning value $v to ${current.runtimeType}';
  +    }
  +
  +    if (initializers.length <= 1) {
  +      // todo: return configuration for body of ctr.
  +      return new ContinuationConfiguration(continuation, newObject);
  +    }
  +
  +    Initializer next = initializers[1];
  +
  +    if (next is RedirectingInitializer) {
  +      var cont = new ConstructorInvocationApplication(
  +          newObject, next.target, continuation);
  +      var args =
  +          _createArgumentExpressionList(next.arguments, next.target.function);
  +      return new ExpressionListConfiguration(
  +          args, initializerEnvironment, cont);
  +    }
  +
  +    if (next is SuperInitializer) {
  +      // todo: eval args for super.
  +      if (currentClass.superclass.superclass != null) {
  +        throw 'Super initializer invocation is not supported.';
         }
  -    }
  -
  -    if (remainingInitializers.isNotEmpty) {
  -      assert(remainingInitializers.first is SuperInitializer);
  -      // todo: Evaluate arguments for super invocation.
  -    }
  -
  -    return new ContinuationConfiguration(expressionContinuation, newObject);
  +      return new ContinuationConfiguration(continuation, newObject);
  +    }
  +
  +    var cont = new InitializerContinuation(newObject, currentClass,
  +        initializerEnvironment, initializers.skip(1), continuation);
  +    return new ExpressionConfiguration(
  +        _getExpression(next), initializerEnvironment, cont);
     }
   }
   
  
positive.code: 
      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);
      }
  
      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
  
negative.code: }
  
  /// Represents the application continuation applied on the list of evaluated
  /// field initializer expressions.
  class InstanceFieldsApplication extends ApplicationContinuation {
    final ObjectValue newObject;
  