Add support for static invocation with arguments

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;
 
 class NotImplemented {
   String message;
@@ skipping 113 matching lines @@
           StaticSet node, ExpressionConfiguration config) =>
       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 {
-      // Currently supports only static invocations with no arguments.
-      if (node.arguments.positional.isEmpty && node.arguments.named.isEmpty) {
-        State statementState = new State.initial()
-            .withExpressionContinuation(config.continuation)
-            .withConfiguration(new ExitConfiguration(config.continuation));
-
-        return new StatementConfiguration(
-            node.target.function.body, statementState);
-      }
-      throw new NotImplemented(
-          'Support for static invocation with arguments is not implemented');
+      var cont = new ActualArgumentsContinuation(node.arguments,
+          node.target.function, config.environment, config.continuation);
+      return cont.createCurrentConfiguration();
     }
   }
 
   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 256 matching lines @@
 
   SetterContinuation(this.receiver, this.name, this.continuation);
 
   Configuration call(Value v) {
     Setter setter = receiver.class_.lookupSetter(name);
     setter(receiver, v);
     return new ContinuationConfiguration(continuation, v);
   }
 }
 
-class StaticInvocationContinuation extends ExpressionContinuation {
+/// 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;
+  final Environment environment;
   final ExpressionContinuation continuation;
 
-  StaticInvocationContinuation(this.continuation);
+  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);
 
   Configuration call(Value v) {
-    return new ContinuationConfiguration(continuation, v);
+    if (_currentPositional < arguments.positional.length) {
+      _positional.add(v);
+      _currentPositional++;
+    } else {
+      assert(_currentNamed < arguments.named.length);
+      String name = arguments.named[_currentNamed].name;
+      _named[name] = v;
+      _currentNamed++;
+    }
+
+    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();
   }
 }
 
+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;
+
+  OptionalArgumentsContinuation(this.positional, this.named, this.functionNode,
+      this.environment, this.continuation)
+      : _currentPositional = positional.length {
+    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
+      assert(_currentPositional >= functionNode.requiredParameterCount);

[Dmitry Stefantsov, 2017/04/21 13:49:36]

I think we can make this assertion once, in the constructor.

[zhivkag, 2017/04/21 16:44:01]

Done.

+      positional.add(v);
+      _currentPositional++;
+    } else {
+      // Value is a optional named argument.
+      String name = _missingFormalNamed.keys.first;

[Dmitry Stefantsov, 2017/04/21 13:49:36]

I think we need to find another way of determining the name of the named
argument here. The order in ".keys" may be implementation-specific and may
change when the map is modified or copied. Using ".keys.first" here adds some
implicit constraints to the modification of the code in future:

(1) The "_missingFormalNamed" should not be modified between the previous call
to "createCurrentConfiguration" (where ".keys.first" is also used, and we need
to sync with that) and the subsequent call to "call" on the same object.

(2) The "_missingFormalNamed" should not be copied and replaced with its copy.
The same goes for the enclosing OptionalArgumentsContinuation. If in future we
decide to not use indices to track the progress on arguments evaluation, but
rather create a new OptionalArgumentsContinuation that is more defined than the
previous one, that'll be an issue.

I propose getting here (and in "createCurrentConfiguration" below) the fist name
in lexicographical order. Maybe, there's a better approach for passing the name
of the argument from "createCurrentConfiguration" here.

[zhivkag, 2017/04/21 16:44:01]

Done. Indeed, another approach for this would be better. I have opted for saving
the Name of the parameter for which we are evaluating the initializer, which
stays similar to the way we deal with positional arguments. 

+      named[name] = v;
+      _missingFormalNamed.remove(name);
+    }
+
+    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.
+      String next = _missingFormalNamed.keys.first;
+      return new ExpressionConfiguration(
+          _missingFormalNamed[next].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);
+  }
+
+  /// 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() {
+    Environment newEnv = new Environment.empty();
+    // Add positional parameters.
+    for (int i = 0; i < positional.length; ++i) {
+      newEnv.expand(functionNode.positionalParameters[i], positional[i]);
+    }
+    // Add named parameters.
+    for (VariableDeclaration v in functionNode.namedParameters) {
+      newEnv.expand(v, named[v.name.toString()]);
+    }
+
+    return newEnv;
+  }
+}
+
 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 530 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');
 }