add Resolver class

Environment.cpp

@@ -27,8 +27,12 @@ Object Environment::get(Token name) {
     throw RuntimeError(name, "Undefined variable '" + name.lexeme + "'.");
 }
 
+Object Environment::getAt(int distance, string name) {
+  return ancestor(distance)->values[name];
+}
+
 void Environment::assign(Token name, Object value) {
-  auto search = values.find(name.lexeme);
+    auto search = values.find(name.lexeme);
     if (search != values.end()) {
       search->second = value;
       return;
@@ -39,4 +43,16 @@ void Environment::assign(Token name, Object value) {
     }
 
     throw RuntimeError(name, "Undefined variable '" + name.lexeme + "'.");
+}
+
+void Environment::assignAt(int distance, Token name, Object value) {
+    ancestor(distance)->values[name.lexeme] = value;
+}
+
+shared_ptr<Environment> Environment::ancestor(int distance) {
+    shared_ptr<Environment> environment = shared_from_this();
+    for (int i = 0; i < distance; i++) {
+        environment = environment->enclosing;
+    }
+    return environment;
 }

Environment.hpp

@@ -12,13 +12,16 @@ using std::map;
 using std::string;
 using std::shared_ptr;
 
-class Environment {
+class Environment: public std::enable_shared_from_this<Environment> {
  public:
     Environment() = default;
     explicit Environment(shared_ptr<Environment> enclosing);
     void define(string name, Object value);
     void assign(Token name, Object value);
     Object get(Token name);
+    Object getAt(int distance, string name);
+    void assignAt(int distance, Token name, Object value);
+    shared_ptr<Environment> ancestor(int distance);
  private:
     shared_ptr<Environment> enclosing;
     map<string, Object> values;

Expr.hpp

@@ -43,17 +43,17 @@ template <class R>
 class Visitor {
  public:
     virtual ~Visitor() = default;
-    virtual R visitLiteralExpr(const Literal<R>& expr) = 0;
-    virtual R visitAssignExpr(const Assign<R>& expr) = 0;
-    virtual R visitBinaryExpr(const Binary<R>& expr) = 0;
-    virtual R visitGroupingExpr(const Grouping<R>& expr) = 0;
-    virtual R visitUnaryExpr(const Unary<R>& expr) = 0;
-    virtual R visitVariableExpr(const Variable<R>& expr) = 0;
-    virtual R visitLogicalExpr(const Logical<R>& expr) = 0;
-    virtual R visitCallExpr(const Call<R>& expr) = 0;
-    // virtual string visitSetExpr(const Set& expr) = 0;
-    // virtual string visitSuperExpr(const Super& expr) = 0;
-    // virtual string visitThisExpr(const This& expr) = 0;
+    virtual R visitLiteralExpr(shared_ptr<Literal<R>> expr) = 0;
+    virtual R visitAssignExpr(shared_ptr<Assign<R>> expr) = 0;
+    virtual R visitBinaryExpr(shared_ptr<Binary<R>> expr) = 0;
+    virtual R visitGroupingExpr(shared_ptr<Grouping<R>> expr) = 0;
+    virtual R visitUnaryExpr(shared_ptr<Unary<R>> expr) = 0;
+    virtual R visitVariableExpr(shared_ptr<Variable<R>> expr) = 0;
+    virtual R visitLogicalExpr(shared_ptr<Logical<R>> expr) = 0;
+    virtual R visitCallExpr(shared_ptr<Call<R>> expr) = 0;
+    // virtual string visitSetExpr(Set& expr) = 0;
+    // virtual string visitSuperExpr(Super& expr) = 0;
+    // virtual string visitThisExpr(This& expr) = 0;
 };
 
 template<class R>
@@ -64,30 +64,39 @@ class Expr {
 };
 
 template<class R>
-class Literal: public Expr<R> {
+class Literal:
+    public Expr<R>,
+    public std::enable_shared_from_this<Literal<R>>
+{
  public:
     explicit Literal(R value_): value(value_) { }
     R accept(shared_ptr<Visitor<R>> visitor) override {
-        return visitor->visitLiteralExpr(*this);
+        return visitor->visitLiteralExpr(this->shared_from_this());
     }
     R value;
 };
 
 template <class R>
-class Assign: public Expr<R> {
+class Assign:
+    public Expr<R>,
+    public std::enable_shared_from_this<Assign<R>>
+{
  public:
     Assign(Token name_, shared_ptr<Expr<R>> value_):
     name(name_), value(value_) {}
 
     R accept(shared_ptr<Visitor<R>> visitor) override {
-        return visitor->visitAssignExpr(*this);
+        return visitor->visitAssignExpr(this->shared_from_this());
     }
     Token name;
     shared_ptr<Expr<R>> value;
 };
 
 template <class R>
-class Binary: public Expr<R> {
+class Binary:
+    public Expr<R>,
+    public std::enable_shared_from_this<Binary<R>>
+{
  public:
     Binary(
         shared_ptr<Expr<R>> left_,
@@ -96,74 +105,89 @@ class Binary: public Expr<R> {
     left(left_), operation(operation), right(right_) { }
 
     R accept(shared_ptr<Visitor<R>> visitor) override {
-      return visitor->visitBinaryExpr(*this);
+      return visitor->visitBinaryExpr(this->shared_from_this());
     }
     shared_ptr<Expr<R>> left;
     Token operation;
     shared_ptr<Expr<R>> right;
 };
 
 template <class R>
-class Grouping: public Expr<R> {
+class Grouping:
+    public Expr<R>,
+    public std::enable_shared_from_this<Grouping<R>>
+{
  public:
     explicit Grouping(shared_ptr<Expr<R>> expression_):
     expression(expression_) { }
 
     R accept(shared_ptr<Visitor<R>> visitor) override {
-        return visitor->visitGroupingExpr(*this);
+        return visitor->visitGroupingExpr(this->shared_from_this());
     }
     shared_ptr<Expr<R>> expression;
 };
 
 template <class R>
-class Unary: public Expr<R> {
+class Unary:
+    public Expr<R>,
+    public std::enable_shared_from_this<Unary<R>>
+{
  public:
     Unary(Token operation, shared_ptr<Expr<R>> right_):
     operation(operation), right(right_) { }
 
     R accept(shared_ptr<Visitor<R>> visitor) override {
-      return visitor->visitUnaryExpr(*this);
+      return visitor->visitUnaryExpr(this->shared_from_this());
     }
     Token operation;
     shared_ptr<Expr<R>> right;
 };
 
 template <class R>
-class Variable: public Expr<R> {
+class Variable:
+    public Expr<R>,
+    public std::enable_shared_from_this<Variable<R>>
+{
  public:
     explicit Variable(Token name_): name(name_) { }
     R accept(shared_ptr<Visitor<R>> visitor) override {
-        return visitor->visitVariableExpr(*this);
+        return visitor->visitVariableExpr(this->shared_from_this());
     };
     Token name;
 };
 
 template <class R>
-class Logical: public Expr<R> {
+class Logical:
+    public Expr<R>,
+    public std::enable_shared_from_this<Logical<R>>
+{
  public:
     Logical(
         shared_ptr<Expr<R>> left_,
         Token operation_,
         shared_ptr<Expr<R>> right_):
     left(left_), operation(operation_), right(right_) { }
     R accept(shared_ptr<Visitor<R>> visitor) override {
-        return visitor->visitLogicalExpr(*this);
+        return visitor->visitLogicalExpr(this->shared_from_this());
     };
     shared_ptr<Expr<R>> left;
     Token operation;
     shared_ptr<Expr<R>> right;
 };
 
 template <class R>
-class Call: public Expr<R> {
+class Call:
+    public Expr<R>,
+    public std::enable_shared_from_this<Call<R>>
+{
  public:
     Call(
         shared_ptr<Expr<R>> callee_,
         Token paren_,
         vector<shared_ptr<Expr<R>>> arguments_):
     callee(callee_), paren(paren_), arguments(arguments_) { }
     R accept(shared_ptr<Visitor<R>> visitor) override {
-      return visitor->visitCallExpr(*this);
+      return visitor->visitCallExpr(this->shared_from_this());
     }
     shared_ptr<Expr<R>> callee;
     Token paren;