Implement support for static accessors

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';
 
 class NotImplemented {
   String message;
 
   NotImplemented(this.message);
 
   String toString() => message;
 }
 
 class Interpreter {
   Program program;
   StatementExecuter visitor = new StatementExecuter();
 
+  // The execution of the program starts with empty main environment.
+  static MainEnvironment mainEnvironment =
+      new MainEnvironment(<Member, Location>{});
+
   Interpreter(this.program);
 
   void run() {
     assert(program.libraries.isEmpty);
     Procedure mainMethod = program.mainMethod;
 
     if (mainMethod == null) return;
 
     Statement statementBlock = mainMethod.function.body;
     ExecConfiguration configuration = new ExecConfiguration(
         statementBlock, new Environment.empty(), new State.initial());
     visitor.trampolinedExecution(configuration);
   }
 }
 
 class Location {
   Value value;
 
   Location.empty();
   Location(this.value);
 }
 
 class Binding {
   final VariableDeclaration variable;
   final Location location;
 
   Binding(this.variable, this.location);
 }
 
+/// Represents the top level environment that binds previously accessed or set
+/// static fields to the location that stores their value.
+class MainEnvironment {
+  final Map<Member, Location> _staticFields;
+
+  MainEnvironment(this._staticFields);
+
+  bool contains(Member member) => _staticFields[member] != null;
+
+  Value lookup(Member member) {
+    assert(contains(member));
+    return _staticFields[member].value;
+  }
+
+  void updateStore(Member member, Value value) {
+    assert(contains(member));
+    _staticFields[member].value = value;
+  }
+
+  MainEnvironment extend(Member member, Value value) {
+    var newMap = new Map<Member, Location>.from(_staticFields);
+    newMap[member] = new Location(value);
+    return new MainEnvironment(newMap);
+  }
+}
+
 class Environment {
   final List<Binding> bindings = <Binding>[];
   final Environment parent;
 
   Value get thisInstance {
     return containsThis()
         ? lookupThis().value
         : throw "Invalid reference to 'this' expression";
   }
 
@@ skipping 27 matching lines @@
     for (Binding b in bindings) {
       if (identical(b.variable.name, 'this')) return b.location;
     }
     return parent.lookupThis();
   }
 
   Value lookup(VariableDeclaration variable) {
     return lookupBinding(variable).location.value;
   }
 
-  void assign(VariableDeclaration variable, Value value) {
+  void updateStore(VariableDeclaration variable, Value value) {
     assert(contains(variable));
     lookupBinding(variable).location.value = value;
   }
 
   Environment extend(VariableDeclaration variable, Value value) {
     assert(!contains(variable));
     return new Environment(this)
       ..bindings.add(new Binding(variable, new Location(value)));
   }
 
@@ skipping 49 matching lines @@
         node.receiver, config.environment, config.exceptionComponents, cont);
   }
 
   Configuration visitPropertySet(PropertySet node, EvalConfiguration config) {
     var cont = new PropertySetEK(node.value, node.name, config.environment,
         config.exceptionComponents, config.continuation);
     return new EvalConfiguration(
         node.receiver, config.environment, config.exceptionComponents, cont);
   }
 
-  Configuration visitStaticGet(StaticGet node, EvalConfiguration config) =>
-      defaultExpression(node, config);
-  Configuration visitStaticSet(StaticSet node, EvalConfiguration config) =>
-      defaultExpression(node, config);
+  Configuration visitStaticGet(StaticGet node, EvalConfiguration config) {
+    Member member = node.target;
+
+    if (member is Procedure && !member.isAccessor) {
+      // Create a closure for the method tear off.
+      var v = new FunctionValue(member.function, new Environment.empty());
+      return new ValuePassingConfiguration(config.continuation, v);
+    }
+
+    if (member is Procedure && member.isGetter) {
+      // Execute the body of the getter.
+      var state = new State.initial()
+          .withReturnContinuation(config.continuation)
+          .withContinuation(new ExitSK(config.continuation, Value.nullInstance))
+          .withException(config.exceptionComponents);
+      return new ExecConfiguration(
+          member.function.body, new Environment.empty(), state);
+    }
+
+    assert(member is Field);
+    if (Interpreter.mainEnvironment.contains(member)) {
+      // Read the value for the member in the main environment.
+      return new ValuePassingConfiguration(
+          config.continuation, Interpreter.mainEnvironment.lookup(member));
+    }
+
+    // Otherwise, the static field is accessed for the first time.
+    // We extend the main environment with a new binding.
+    Interpreter.mainEnvironment =
+        Interpreter.mainEnvironment.extend(member, Value.nullInstance);
+
+    if ((member as Field).initializer == null) {
+      return new ValuePassingConfiguration(
+          config.continuation, Value.nullInstance);
+    }
+
+    // The initializer expression is evaluated otherwise.
+    var cont = new StaticSetEK(member, config.continuation);
+    return new EvalConfiguration((member as Field).initializer,
+        new Environment.empty(), config.exceptionComponents, cont);
+  }
+
+  Configuration visitStaticSet(StaticSet node, EvalConfiguration config) {
+    Member member = node.target;
+    ExpressionContinuation cont;
+
+    if (member is Procedure) {
+      assert(member.isSetter);
+      cont = new StaticSetterEK(
+          member.function, config.exceptionComponents, config.continuation);
+    } else {
+      assert(member is Field);
+      cont = new StaticSetEK(member, config.continuation);
+    }
+
+    return new EvalConfiguration(
+        node.value, config.environment, config.exceptionComponents, cont);
+  }
 
   Configuration visitStaticInvocation(
       StaticInvocation node, EvalConfiguration config) {
     if ('print' == node.name.toString()) {
       var cont = new PrintEK(config.continuation);
       return new EvalConfiguration(node.arguments.positional.first,
           config.environment, config.exceptionComponents, cont);
     } else {
       log.info('static-invocation-${node.target.name.toString()}\n');
 
@@ skipping 72 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, 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 132 matching lines @@
 }
 
 /// Configuration for execution of a [Statement].
 class ExecConfiguration extends Configuration {
   final Statement currentStatement;
   final Environment environment;
   final State state;
 
   ExecConfiguration(this.currentStatement, this.environment, this.state);
 
-  Configuration step(StatementExecuter executer) =>
-      executer.exec(currentStatement, this);
+  Configuration step(StatementExecuter executer) {
+    return executer.exec(currentStatement, this);
+  }
 }
 
 /// Configuration for applying a [StatementContinuation] to an [Environment].
 class ForwardConfiguration extends Configuration {
   final StatementContinuation continuation;
   final Environment environment;
 
   ForwardConfiguration(this.continuation, this.environment);
 
   Configuration step(StatementExecuter _) => continuation?.call(environment);
@@ skipping 455 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.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 59 matching lines @@
 
   SetterEK(this.receiver, this.name, this.continuation);
 
   Configuration call(Value v) {
     Setter setter = receiver.class_.lookupImplicitSetter(name);
     setter(receiver, v);
     return new ValuePassingConfiguration(continuation, v);
   }
 }
 
+class StaticSetEK extends ExpressionContinuation {
+  final Member member;
+  final ExpressionContinuation continuation;
+
+  StaticSetEK(this.member, this.continuation);
+
+  Configuration call(Value v) {
+    if (Interpreter.mainEnvironment.contains(member)) {
+      Interpreter.mainEnvironment.updateStore(member, v);
+    } else {
+      Interpreter.mainEnvironment =
+          Interpreter.mainEnvironment.extend(member, v);
+    }
+    return new ValuePassingConfiguration(continuation, v);
+  }
+}
+
+class StaticSetterEK extends ExpressionContinuation {
+  final FunctionNode setter;
+  final ExceptionComponents exceptionComponents;
+  final ExpressionContinuation expressionContinuation;
+
+  StaticSetterEK(
+      this.setter, this.exceptionComponents, this.expressionContinuation);
+
+  Configuration call(Value v) {
+    VariableDeclaration arg = setter.positionalParameters.first;
+    var env = new Environment.empty().extend(arg, v);
+    var state = new State.initial()
+        .withException(exceptionComponents)
+        .withReturnContinuation(expressionContinuation)
+        .withContinuation(
+            new ExitSK(expressionContinuation, Value.nullInstance));
+
+    return new ExecConfiguration(setter.body, env, state);
+  }
+}
+
 /// Represents a continuation to be called after the evaluation of an actual
 /// argument for function invocation.
 class ExpressionListEK extends ExpressionContinuation {
   final InterpreterExpression currentExpression;
   final List<InterpreterExpression> expressions;
   final Environment environment;
   final ExceptionComponents exceptionComponents;
   final ApplicationContinuation applicationContinuation;
 
   ExpressionListEK(this.currentExpression, this.expressions, this.environment,
@@ skipping 11 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 18 matching lines @@
 }
 
 class VariableSetEK extends ExpressionContinuation {
   final VariableDeclaration variable;
   final Environment environment;
   final ExpressionContinuation continuation;
 
   VariableSetEK(this.variable, this.environment, this.continuation);
 
   Configuration call(Value value) {
-    environment.assign(variable, value);
+    environment.updateStore(variable, value);
     return new ValuePassingConfiguration(continuation, value);
   }
 }
 
 class NotEK extends ExpressionContinuation {
   final ExpressionContinuation continuation;
 
   NotEK(this.continuation);
 
   Configuration call(Value value) {
@@ skipping 61 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 356 matching lines @@
     return new EvalConfiguration(node.expression, conf.environment,
         conf.state.exceptionComponents, cont);
   }
 
   Configuration visitBlock(Block node, ExecConfiguration conf) {
     if (node.statements.isEmpty) {
       return new ForwardConfiguration(
           conf.state.continuation, conf.environment);
     }
 
-    var env = new Environment(conf.environment);
     var cont = new BlockSK.fromConfig(node.statements.skip(1).toList(), conf);
-    return new ExecConfiguration(
-        node.statements.first, env, conf.state.withContinuation(cont));
+    return new ExecConfiguration(node.statements.first, conf.environment,
+        conf.state.withContinuation(cont));
   }
 
   Configuration visitEmptyStatement(
       EmptyStatement node, ExecConfiguration conf) {
     return new ForwardConfiguration(conf.state.continuation, conf.environment);
   }
 
   Configuration visitIfStatement(IfStatement node, ExecConfiguration conf) {
     var cont = new IfConditionEK(
         node.then, node.otherwise, conf.environment, conf.state);
@@ skipping 75 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 newEnv = conf.environment.extend(node.variable, Value.nullInstance);
+    var fun = new FunctionValue(node.function, newEnv);
+    newEnv.updateStore(node.variable, fun);
+    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 Environment environment;
+
+  FunctionValue(this.function, this.environment);
+}
+
 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;
     }
   }
 }