Refactor argument evaluation for static invocation

pkg/kernel/lib/interpreter/interpreter.dart

 // Copyright (c) 2017, 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.interpreter;
 
 import '../ast.dart';
 import '../ast.dart' as ast show Class;
 
 import '../log.dart';
 export '../log.dart';
@@ skipping 68 matching lines @@
     bindings.add(new Binding(variable, value));
   }
 }
 
 /// Evaluate expressions.
 class Evaluator
     extends ExpressionVisitor1<Configuration, ExpressionConfiguration> {
   Configuration eval(Expression expr, ExpressionConfiguration config) =>
       expr.accept1(this, config);
 
+  Configuration evalArgs(List<ArgumentExpression> args, Environment env,
+      ApplicationContinuation cont) {
+    if (args.isNotEmpty) {
+      return new ExpressionConfiguration(args.first.expression, env,
+          new ActualArgumentsContinuation(args.first, args.skip(1), env, cont));
+    }
+    return new ArgumentContinuationConfiguration(cont, <ArgumentValue>[]);
+  }
+
   Configuration defaultExpression(
       Expression node, ExpressionConfiguration config) {
     throw new NotImplemented('Evaluation for expressions of type '
         '${node.runtimeType} is not implemented.');
   }
 
   Configuration visitInvalidExpression1(
       InvalidExpression node, ExpressionConfiguration config) {
     throw 'Invalid expression at ${node.location.toString()}';
   }
@@ skipping 32 matching lines @@
       defaultExpression(node, config);
 
   Configuration visitStaticInvocation(
       StaticInvocation node, ExpressionConfiguration config) {
     if ('print' == node.name.toString()) {
       var cont = new PrintContinuation(config.continuation);
       return new ExpressionConfiguration(
           node.arguments.positional.first, config.environment, cont);
     } else {
       log.info('static-invocation-${node.target.name.toString()}\n');
-      var cont = new ActualArgumentsContinuation(node.arguments,
-          node.target.function, config.environment, config.continuation);
-      return cont.createCurrentConfiguration();
+
+      List<ArgumentExpression> args =
+          _createArgumentExpressionList(node.arguments, node.target.function);
+      ApplicationContinuation cont = new StaticInvocationApplication(
+          node.target.function, config.continuation);
+      return new ArgumentsConfiguration(args, config.environment, cont);
     }
   }
 
   Configuration visitMethodInvocation(
       MethodInvocation node, ExpressionConfiguration config) {
     // Currently supports only method invocation with <2 arguments and is used
     // to evaluate implemented operators for int, double and String values.
     var cont = new MethodInvocationContinuation(
         node.arguments, node.name, config.environment, config.continuation);
 
@@ skipping 167 matching lines @@
   }
 }
 
 /// Represents the configuration for applying an [ExpressionContinuation].
 class ContinuationConfiguration extends Configuration {
   final ExpressionContinuation continuation;
   final Value value;
 
   ContinuationConfiguration(this.continuation, this.value);
 
-  Configuration step(StatementExecuter executer) => continuation(value);
+  Configuration step(StatementExecuter _) => continuation(value);
+}
+
+/// Represents the configuration for applying an [ApplicationContinuation].
+class ArgumentContinuationConfiguration extends Configuration {
+  final ApplicationContinuation continuation;
+  final List<ArgumentValue> argumentValues;
+
+  ArgumentContinuationConfiguration(this.continuation, this.argumentValues);
+
+  Configuration step(StatementExecuter _) => continuation(argumentValues);
 }
 
 /// Represents the configuration for evaluating an [Expression].
 class ExpressionConfiguration extends Configuration {
   final Expression expression;
 
   /// Environment in which the expression is evaluated.
   final Environment environment;
 
   /// Next continuation to be applied.
-  final ExpressionContinuation continuation;
+  final Continuation continuation;
 
   ExpressionConfiguration(this.expression, this.environment, this.continuation);
 
   Configuration step(StatementExecuter executer) =>
       executer.eval(expression, this);
 }
 
+/// Represents the configuration for evaluating a list of argument expressions.
+class ArgumentsConfiguration extends Configuration {
+  final List<ArgumentExpression> arguments;
+  final Environment environment;
+  final Continuation continuation;
+
+  ArgumentsConfiguration(this.arguments, this.environment, this.continuation);
+
+  Configuration step(StatementExecuter executer) =>
+      executer.evalArgs(arguments, environment, continuation);
+}
+
+abstract class ArgumentExpression {
+  String get name;
+  Expression get expression;
+}
+
+class PositionalArgumentExpression extends ArgumentExpression {
+  String get name => throw 'PositionalArgumentExpression has no name';

[Dmitry Stefantsov, 2017/05/10 08:08:49]

It's not clear why we define "name" getter in ArgumentExpression and throw an
exception here, but not follow the same pattern with ArgumentValue and
PositionalArgumentValue below (the "name" field is not defined in ArgumentValue
class).

[zhivkag, 2017/05/10 08:27:07]

I initially intended to have name for both, but finally decided to only add the
name attribute for the named expressions and values. I must have forgotten to
remove it here. Done.

I removed the name attribute because later we might have more general
interpreter expressions (for example for field and local initializers), which
will have other attributes and the only common one is an expression getter.   

+  final Expression expression;
+
+  PositionalArgumentExpression(this.expression);
+}
+
+class NamedArgumentExpression extends ArgumentExpression {
+  final String name;
+  final Expression expression;
+
+  NamedArgumentExpression(this.name, this.expression);
+}
+
+abstract class ArgumentValue {
+  Value get value;
+}
+
+class PositionalArgumentValue extends ArgumentValue {
+  final Value value;
+
+  PositionalArgumentValue(this.value);
+}
+
+class NamedArgumentValue extends ArgumentValue {
+  final String name;
+  final Value value;
+
+  NamedArgumentValue(this.name, this.value);
+}
+
+abstract class Continuation {}
+
+// ------------------------------------------------------------------------
+//                       EXPRESSION CONTINUATIONS
+// ------------------------------------------------------------------------
+
 /// Represents an expression continuation.
-abstract class ExpressionContinuation {
+abstract class ExpressionContinuation extends Continuation {
   Configuration call(Value v);
 }
 
 /// Represents a continuation that returns the next [StatementConfiguration]
 /// to be executed.
 class ExpressionStatementContinuation extends ExpressionContinuation {
   final StatementConfiguration configuration;
 
   ExpressionStatementContinuation(this.configuration);
 
@@ skipping 52 matching lines @@
   Configuration call(Value v) {
     Setter setter = receiver.class_.lookupSetter(name);
     setter(receiver, v);
     return new ContinuationConfiguration(continuation, v);
   }
 }
 
 /// Represents a continuation to be called after the evaluation of an actual
 /// argument for function invocation.
 /// TODO: Add checks for validation of arguments according to spec.
-class ActualArgumentsContinuation extends ExpressionContinuation {
-  final Arguments arguments;
-  final FunctionNode functionNode;
+class ActualArgumentsContinuation extends Continuation {
+  final ArgumentExpression currentArgument;
+  final List<ArgumentExpression> arguments;
   final Environment environment;
-  final ExpressionContinuation continuation;
+  final ApplicationContinuation applicationContinuation;
 
-  final List<Value> _positional = <Value>[];
-  int _currentPositional = 0;
-  final Map<String, Value> _named = <String, Value>{};
-  int _currentNamed = 0;
-
-  ActualArgumentsContinuation(
-      this.arguments, this.functionNode, this.environment, this.continuation);
+  ActualArgumentsContinuation(this.currentArgument, this.arguments,
+      this.environment, this.applicationContinuation);
 
   Configuration call(Value v) {
-    if (_currentPositional < arguments.positional.length) {
-      _positional.add(v);
-      _currentPositional++;
+    ArgumentValue argumentValue;
+    if (currentArgument is NamedArgumentExpression) {
+      argumentValue = new NamedArgumentValue(currentArgument.name, v);
     } else {
-      assert(_currentNamed < arguments.named.length);
-      String name = arguments.named[_currentNamed].name;
-      _named[name] = v;
-      _currentNamed++;
+      argumentValue = new PositionalArgumentValue(v);
     }
 
-    return createCurrentConfiguration();
-  }
-
-  Configuration createCurrentConfiguration() {
-    // Next argument to evaluate is a provided positional argument.
-    if (_currentPositional < arguments.positional.length) {
-      return new ExpressionConfiguration(
-          arguments.positional[_currentPositional], environment, this);
-    }
-    // Next argument to evaluate is a provided named argument.
-    if (_currentNamed < arguments.named.length) {
-      return new ExpressionConfiguration(
-          arguments.named[_currentNamed].value, environment, this);
-    }
-
-    // TODO: check if the number of actual arguments is larger then the number
-    // of required arguments and smaller then the number of formal arguments.
-
-    return new OptionalArgumentsContinuation(
-            _positional, _named, functionNode, environment, continuation)
-        .createCurrentConfiguration();
+    return new ArgumentsConfiguration(arguments, environment,
+        new ArgumentValueApplication(argumentValue, applicationContinuation));
   }
 }
 
-class OptionalArgumentsContinuation extends ExpressionContinuation {
-  final List<Value> positional;
-  final Map<String, Value> named;
-  final FunctionNode functionNode;
-  final Environment environment;
-  final ExpressionContinuation continuation;
-
-  final Map<String, VariableDeclaration> _missingFormalNamed =
-      <String, VariableDeclaration>{};
-
-  int _currentPositional;
-  String _currentNamed;
-
-  OptionalArgumentsContinuation(this.positional, this.named, this.functionNode,
-      this.environment, this.continuation) {
-    _currentPositional = positional.length;
-    assert(_currentPositional >= functionNode.requiredParameterCount);
-
-    for (VariableDeclaration vd in functionNode.namedParameters) {
-      if (named[vd.name] == null) {
-        _missingFormalNamed[vd.name] = vd;
-      }
-    }
-  }
-
-  Configuration call(Value v) {
-    if (_currentPositional < functionNode.positionalParameters.length) {
-      // Value is a optional positional argument
-      positional.add(v);
-      _currentPositional++;
-    } else {
-      // Value is a optional named argument.
-      assert(named[_currentNamed] == null);
-      named[_currentNamed] = v;
-    }
-
-    return createCurrentConfiguration();
-  }
-
-  /// Creates the current configuration for the evaluation of invocation a
-  /// function.
-  Configuration createCurrentConfiguration() {
-    if (_currentPositional < functionNode.positionalParameters.length) {
-      // Next argument to evaluate is a missing positional argument.
-      // Evaluate its initializer.
-      return new ExpressionConfiguration(
-          functionNode.positionalParameters[_currentPositional].initializer,
-          environment,
-          this);
-    }
-    if (named.length < functionNode.namedParameters.length) {
-      // Next argument to evaluate is a missing named argument.
-      // Evaluate its initializer.
-      _currentNamed = _missingFormalNamed.keys.first;
-      Expression initializer = _missingFormalNamed[_currentNamed].initializer;
-      _missingFormalNamed.remove(_currentNamed);
-      return new ExpressionConfiguration(initializer, environment, this);
-    }
-
-    Environment newEnv = _createEnvironment();
-    State bodyState = new State.initial()
-        .withExpressionContinuation(continuation)
-        .withConfiguration(new ExitConfiguration(continuation))
-        .withEnvironment(newEnv);
-
-    return new StatementConfiguration(functionNode.body, bodyState);
-  }
+/// Represents the continuation called after the evaluation of argument
+/// expressions.
+abstract class ApplicationContinuation extends Continuation {
+  Configuration call(List<ArgumentValue> args);
 
   /// Creates an environment binding actual argument values to formal parameters
   /// of the function in a new environment, which is used to execute the
   /// body od the function.
-  Environment _createEnvironment() {
+  static Environment createEnvironment(
+      FunctionNode function, List<ArgumentValue> args) {
     Environment newEnv = new Environment.empty();
+    List<PositionalArgumentValue> positional = args.reversed
+        .where((ArgumentValue av) => av is PositionalArgumentValue)
+        .toList();
+
     // Add positional parameters.
     for (int i = 0; i < positional.length; ++i) {
-      newEnv.expand(functionNode.positionalParameters[i], positional[i]);
+      newEnv.expand(function.positionalParameters[i], positional[i].value);
     }
+
+    Map<String, Value> named = new Map.fromIterable(
+        args.where((ArgumentValue av) => av is NamedArgumentValue),
+        key: (NamedArgumentValue av) => av.name,
+        value: (NamedArgumentValue av) => av.value);
+
     // Add named parameters.
-    for (VariableDeclaration v in functionNode.namedParameters) {
+    for (VariableDeclaration v in function.namedParameters) {
       newEnv.expand(v, named[v.name.toString()]);
     }
 
     return newEnv;
   }
 }
 
+/// Represents the application continuation for static invocation.
+class StaticInvocationApplication extends ApplicationContinuation {
+  final FunctionNode function;
+  final ExpressionContinuation continuation;
+
+  StaticInvocationApplication(this.function, this.continuation);
+
+  Configuration call(List<ArgumentValue> args) {
+    Environment functionEnv =
+        ApplicationContinuation.createEnvironment(function, args);
+
+    State bodyState = new State.initial()
+        .withExpressionContinuation(continuation)
+        .withConfiguration(new ExitConfiguration(continuation))
+        .withEnvironment(functionEnv);
+    return new StatementConfiguration(function.body, bodyState);
+  }
+}
+
+/// Represents the application continuation called after the evaluation of all
+/// argument expressions for an invocation.
+class ArgumentValueApplication extends ApplicationContinuation {
+  final ArgumentValue value;
+  final ApplicationContinuation applicationContinuation;
+
+  ArgumentValueApplication(this.value, this.applicationContinuation);
+
+  Configuration call(List<ArgumentValue> args) {
+    args.add(value);
+    return new ArgumentContinuationConfiguration(applicationContinuation, args);
+  }
+}
+
 class MethodInvocationContinuation extends ExpressionContinuation {
   final Arguments arguments;
   final Name methodName;
   final Environment environment;
   final ExpressionContinuation continuation;
 
   MethodInvocationContinuation(
       this.arguments, this.methodName, this.environment, this.continuation);
 
   Configuration call(Value receiver) {
@@ skipping 212 matching lines @@
   void trampolinedExecution(Configuration configuration) {
     while (configuration != null) {
       configuration = configuration.step(this);
     }
   }
 
   Configuration exec(Statement statement, State state) =>
       statement.accept1(this, state);
   Configuration eval(Expression expression, ExpressionConfiguration config) =>
       evaluator.eval(expression, config);
+  Configuration evalArgs(
+          List<ArgumentExpression> args, Environment env, Continuation cont) =>
+      evaluator.evalArgs(args, env, cont);
 
   Configuration defaultStatement(Statement node, State state) {
     throw notImplemented(
         m: "Execution is not implemented for statement:\n$node ");
   }
 
   Configuration visitInvalidStatement(InvalidStatement node, State state) {
     throw "Invalid statement at ${node.location}";
   }
 
@@ skipping 302 matching lines @@
 
 class NullValue extends LiteralValue {
   Object get value => null;
 
   const NullValue();
 }
 
 notImplemented({String m, Object obj}) {
   throw new NotImplemented(m ?? 'Evaluation for $obj is not implemented');
 }
+
+// ------------------------------------------------------------------------
+//                             INTERNAL FUNCTIONS
+// ------------------------------------------------------------------------
+/// Creates a list of all argument expressions to be evaluated for the
+/// invocation of the provided [FunctionNode] containing the actual arguments
+/// and the optional argument initializers.
+List<ArgumentExpression> _createArgumentExpressionList(
+    Arguments providedArgs, FunctionNode fun) {
+  List<ArgumentExpression> args = <ArgumentExpression>[];
+  // Add positional arguments expressions.
+  args.addAll(providedArgs.positional
+      .map((Expression e) => new PositionalArgumentExpression(e)));
+
+  // Add optional positional argument initializers.
+  for (int i = providedArgs.positional.length;
+      i < fun.positionalParameters.length;
+      i++) {
+    args.add(new PositionalArgumentExpression(
+        fun.positionalParameters[i].initializer));
+  }
+
+  Map<String, NamedArgumentExpression> namedFormals = new Map.fromIterable(
+      fun.namedParameters,
+      key: (VariableDeclaration vd) => vd.name,
+      value: (VariableDeclaration vd) =>
+          new NamedArgumentExpression(vd.name, vd.initializer));
+
+  // Add named expressions.
+  for (int i = 0; i < providedArgs.named.length; i++) {
+    var current = providedArgs.named[i];
+    args.add(new NamedArgumentExpression(current.name, current.value));
+    namedFormals.remove(current.name);
+  }
+
+  // Add missing optional named initializers.
+  args.addAll(namedFormals.values);
+
+  return args;
+}