Add support for function declarations and function expressions

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 25 matching lines @@
   }
 }
 
 class Location {
   Value value;
 
   Location.empty();
   Location(this.value);
 }
 
+class EnvironmentLocation {
+  Environment environment;
+
+  EnvironmentLocation.empty();
+  EnvironmentLocation(this.environment);
+}
+
 class Binding {
   final VariableDeclaration variable;
   final Location location;
 
   Binding(this.variable, this.location);
 }
 
 class Environment {
   final List<Binding> bindings = <Binding>[];
   final Environment parent;
@@ skipping 200 matching lines @@
         config.continuation, config.environment.thisInstance);
   }
 
   Configuration visitThrow(Throw node, EvalConfiguration config) {
     var cont = new ThrowEK(config.exceptionComponents);
 
     return new EvalConfiguration(
         node.expression, config.environment, config.exceptionComponents, cont);
   }
 
+  Configuration visitFunctionExpression(
+      FunctionExpression node, EvalConfiguration config) {
+    var val = new FunctionValue(
+        node.function, new EnvironmentLocation(config.environment));
+    return new ValuePassingConfiguration(config.continuation, val);
+  }
+
   // Evaluation of BasicLiterals.
   Configuration visitStringLiteral(
       StringLiteral node, EvalConfiguration config) {
     return new ValuePassingConfiguration(
         config.continuation, new StringValue(node.value));
   }
 
   Configuration visitIntLiteral(IntLiteral node, EvalConfiguration config) {
     return new ValuePassingConfiguration(
         config.continuation, new IntValue(node.value));
@@ skipping 559 matching lines @@
         ? initializer.value
         : (initializer as LocalInitializer).variable.initializer;
 
     // We start with index = 0 since we are evaluating the expression for the
     // first initializer in the initializer list.
     var cont = new InitializerListEK(constructor, 0, location, environment,
         exceptionComponents, continuation);
     return new EvalConfiguration(expr, environment, exceptionComponents, cont);
   }
 }
+
+class FunctionValueA extends ApplicationContinuation {
+  final FunctionValue receiver;
+  final ExceptionComponents exceptionComponents;
+  final ExpressionContinuation returnContinuation;
+
+  FunctionValueA(
+      this.receiver, this.exceptionComponents, this.returnContinuation);
+
+  Configuration call(List<InterpreterValue> vs) {
+    Environment env = ApplicationContinuation.createEnvironment(
+        receiver.function, vs, receiver.location.environment);
+    var scont = new ExitSK(returnContinuation, Value.nullInstance);
+    var state = new State(null, exceptionComponents, returnContinuation, scont);
+    return new ExecConfiguration(receiver.function.body, env, state);
+  }
+}
+
 // ------------------------------------------------------------------------
 //                           Expression Continuations
 // ------------------------------------------------------------------------
 
 /// Represents an expression continuation.
 ///
 /// There are various kinds of [ExpressionContinuation]s and their names are
 /// suffixed with "EK".
 abstract class ExpressionContinuation extends Continuation {
   Configuration call(Value v);
@@ skipping 90 matching lines @@
   final Arguments arguments;
   final Name methodName;
   final Environment environment;
   final ExceptionComponents exceptionComponents;
   final ExpressionContinuation continuation;
 
   MethodInvocationEK(this.arguments, this.methodName, this.environment,
       this.exceptionComponents, this.continuation);
 
   Configuration call(Value receiver) {
+    if (receiver is FunctionValue) {
+      // TODO(zhivkag): use method lookup instead.
+      assert(methodName.toString() == 'call');
+      var args = _getArgumentExpressions(arguments, receiver.function);
+      var acont =
+          new FunctionValueA(receiver, exceptionComponents, continuation);
+      return new EvalListConfiguration(
+          args, environment, exceptionComponents, acont);
+    }
+
     if (arguments.positional.isEmpty) {
       Value returnValue = receiver.invokeMethod(methodName);
       return new ValuePassingConfiguration(continuation, returnValue);
     }
     var cont = new ArgumentsEK(
         receiver, methodName, arguments, environment, continuation);
 
     return new EvalConfiguration(
         arguments.positional.first, environment, exceptionComponents, cont);
   }
@@ skipping 100 matching lines @@
   final VariableDeclaration variable;
   final Expression letBody;
   final Environment environment;
   final ExceptionComponents exceptionComponents;
   final ExpressionContinuation continuation;
 
   LetEK(this.variable, this.letBody, this.environment, this.exceptionComponents,
       this.continuation);
 
   Configuration call(Value value) {
-    var letEnv = new Environment(environment);
-    letEnv.extend(variable, value);
+    var letEnv = environment.extend(variable, value);
     return new EvalConfiguration(
         letBody, letEnv, exceptionComponents, continuation);
   }
 }
 
 /// Represents the continuation for the condition expression in [WhileStatement].
 class WhileConditionEK extends ExpressionContinuation {
   final Expression condition;
   final Statement body;
   final Environment enclosingEnv;
@@ skipping 452 matching lines @@
       VariableDeclaration node, ExecConfiguration conf) {
     if (node.initializer != null) {
       var cont = new VariableInitializerEK(
           node, conf.environment, conf.state.continuation);
       return new EvalConfiguration(node.initializer, conf.environment,
           conf.state.exceptionComponents, cont);
     }
     return new ForwardConfiguration(conf.state.continuation,
         conf.environment.extend(node, Value.nullInstance));
   }
+
+  Configuration visitFunctionDeclaration(
+      FunctionDeclaration node, ExecConfiguration conf) {
+    var fun = new FunctionValue(node.function, new EnvironmentLocation.empty());
+    var newEnv = conf.environment.extend(node.variable, fun);
+    fun.location.environment = newEnv;
+    return new ForwardConfiguration(conf.state.continuation, newEnv);
+  }
 }
 
 // ------------------------------------------------------------------------
 //                                VALUES
 // ------------------------------------------------------------------------
 
 typedef Value Getter(Value receiver);
 typedef void Setter(Value receiver, Value value);
 
 class Class {
@@ skipping 115 matching lines @@
   Object get value => this;
 
   ObjectValue(this.class_) : fields = new List<Location>(class_.instanceSize) {
     for (int i = 0; i < fields.length; i++) {
       // Create fresh locations for each field.
       fields[i] = new Location.empty();
     }
   }
 }
 
+class FunctionValue extends Value {
+  Class get class_ => throw 'Class for FunctionValue is not defined';
+  List<Location> get fields => throw 'FunctionValue has no fields.';
+
+  FunctionValue get value => this;
+
+  final FunctionNode function;
+  final EnvironmentLocation location;

[Dmitry Stefantsov, 2017/08/16 07:57:54]

Why do we need an [EnvironmentLocation] here?  As I understand it, the
environment doesn't change for a [FunctionValue], so we may just use an
[Environment].  Also, the spec uses an [Environment] in this case.  

[zhivkag, 2017/08/16 08:16:29]

The specification is updated w.r.t. the discussion we had about "recursive"
definition of the FunctionValue and/or the environment two weeks ago.

The discussion was: 
When we define a local function, a variable declaration is associated with it.
The current environment will be extended to bind this variable declaration to
the function value. The function value captures the formals, the body and
environment in scope of the function declaration.

The new binding should be also visible in the captured environment (ex.
recursive functions).
I think this implies that we need to use a location to store the environment and
store the extended environment in it after FunctionValue is created.

[Dmitry Stefantsov, 2017/08/16 08:32:33]

Yes, I remember the discussion.  However, I may have misinterpreted its
conclusion.  My understanding is that we may create a new environment for the
function right away, based on the current environment, with one extra location
for the function value that is yet to be evaluated; `null` can be stored in this
location temporarily.

We may create this environment and use it immediately to form the function
value.  One location in it will be updated after the function value is created.

This way we may avoid having the whole new locations class for storing
environments in locations, i.e. [EnvironmentLocation].  It also feels strange
that a non-value object (an [Environment]) can be stored in locations.

[zhivkag, 2017/08/16 09:33:13]

Thanks for the suggestion, I like this approach better too!

+
+  FunctionValue(this.function, this.location);
+}
+
 abstract class LiteralValue extends Value {
   Class get class_ =>
       notImplemented(m: "Loading class for literal is not implemented.");
   List<Location> get fields =>
       notImplemented(m: "Literal value does not have fields");
 
   const LiteralValue();
 }
 
 class StringValue extends LiteralValue {
@@ skipping 146 matching lines @@
 /// Initializes all non initialized fields from the provided class to
 /// `Value.nullInstance` in the provided value.
 void _initializeNullFields(Class class_, Value value) {
   int startIndex = class_.superclass?.instanceSize ?? 0;
   for (int i = startIndex; i < class_.instanceSize; i++) {
     if (value.fields[i].value == null) {
       value.fields[i].value = Value.nullInstance;
     }
   }
 }