go: Refactor scope in parser and evaluator

Refactor scope in parser and evaluator for both to be private. Rename
`newEnclosedScope` to `newInnerScope` as this term confuses my little
brain a little less. Because `newInnerScope` is now private in
evaluator it triggered an "unused" linter warning, so remove it. We
will re-add it when we need.

It'd be neat to use generics with scope and then re-use the same
implementation for evaluator and parser. However, tinygo doesn't
support generics yet, so we have to do a little bit of copying here.

Author: juliaogris

pkg/evaluator/evaluator.go

@@ -9,7 +9,7 @@ func Run(input string, print func(string)) {
 	prog := p.Parse()
 	e := &Evaluator{print: print}
 	e.builtins = newBuiltins(e)
-	val := e.Eval(prog, NewScope())
+	val := e.Eval(prog, newScope())
 	if isError(val) {
 		print(val.String())
 	}
@@ -20,7 +20,7 @@ type Evaluator struct {
 	builtins map[string]Builtin
 }
 
-func (e *Evaluator) Eval(node parser.Node, scope *Scope) Value {
+func (e *Evaluator) Eval(node parser.Node, scope *scope) Value {
 	switch node := node.(type) {
 	case *parser.Program:
 		return e.evalProgram(node, scope)
@@ -43,7 +43,7 @@ func (e *Evaluator) Eval(node parser.Node, scope *Scope) Value {
 	return nil
 }
 
-func (e *Evaluator) evalProgram(program *parser.Program, scope *Scope) Value {
+func (e *Evaluator) evalProgram(program *parser.Program, scope *scope) Value {
 	var result Value
 	for _, statement := range program.Statements {
 		result = e.Eval(statement, scope)
@@ -54,16 +54,16 @@ func (e *Evaluator) evalProgram(program *parser.Program, scope *Scope) Value {
 	return result
 }
 
-func (e *Evaluator) evalDeclaration(decl *parser.Declaration, scope *Scope) Value {
+func (e *Evaluator) evalDeclaration(decl *parser.Declaration, scope *scope) Value {
 	val := e.Eval(decl.Value, scope)
 	if isError(val) {
 		return val
 	}
-	scope.Set(decl.Var.Name, val)
+	scope.set(decl.Var.Name, val)
 	return nil
 }
 
-func (e *Evaluator) evalFunctionCall(funcCall *parser.FunctionCall, scope *Scope) Value {
+func (e *Evaluator) evalFunctionCall(funcCall *parser.FunctionCall, scope *scope) Value {
 	args := e.evalTerms(funcCall.Arguments, scope)
 	if len(args) == 1 && isError(args[0]) {
 		return args[0]
@@ -75,18 +75,18 @@ func (e *Evaluator) evalFunctionCall(funcCall *parser.FunctionCall, scope *Scope
 	return builtin(args)
 }
 
-func (e *Evaluator) evalVar(v *parser.Var, scope *Scope) Value {
-	if val, ok := scope.Get(v.Name); ok {
+func (e *Evaluator) evalVar(v *parser.Var, scope *scope) Value {
+	if val, ok := scope.get(v.Name); ok {
 		return val
 	}
 	return newError("cannot find variable " + v.Name)
 }
 
-func (e *Evaluator) evalTerm(term parser.Node, scope *Scope) Value {
+func (e *Evaluator) evalTerm(term parser.Node, scope *scope) Value {
 	return e.Eval(term, scope)
 }
 
-func (e *Evaluator) evalTerms(terms []parser.Node, scope *Scope) []Value {
+func (e *Evaluator) evalTerms(terms []parser.Node, scope *scope) []Value {
 	result := make([]Value, len(terms))
 
 	for i, t := range terms {

pkg/evaluator/scope.go

@@ -1,29 +1,25 @@
 package evaluator
 
-type Scope struct {
-	store map[string]Value
-	outer *Scope
+type scope struct {
+	values map[string]Value
+	outer  *scope
 }
 
-func NewScope() *Scope {
-	return &Scope{store: map[string]Value{}}
+func newScope() *scope {
+	return &scope{values: map[string]Value{}}
 }
 
-func NewEnclosedScope(outer *Scope) *Scope {
-	return &Scope{store: map[string]Value{}, outer: outer}
-}
-
-func (s *Scope) Get(name string) (Value, bool) {
+func (s *scope) get(name string) (Value, bool) {
 	if s == nil {
 		return nil, false
 	}
-	if val, ok := s.store[name]; ok {
+	if val, ok := s.values[name]; ok {
 		return val, ok
 	}
-	return s.outer.Get(name)
+	return s.outer.get(name)
 }
 
-func (s *Scope) Set(name string, val Value) Value {
-	s.store[name] = val
+func (s *scope) set(name string, val Value) Value {
+	s.values[name] = val
 	return val
 }

pkg/parser/parser.go

@@ -123,7 +123,7 @@ func (p *Parser) parseFunc(scope *scope) Node {
 
 	p.advancePastNL() // // advance past signature, already parsed into p.funcs earlier
 	fd := p.funcs[funcName]
-	scope = newEnclosedScope(scope)
+	scope = newInnerScope(scope)
 	p.addParamsToScope(scope, fd)
 	block := p.parseBlock(scope) // parse to "end"
 
@@ -524,23 +524,23 @@ func (p *Parser) parseBreakStatment() Node {
 
 //TODO: implemented
 func (p *Parser) parseForStatment(scope *scope) Node {
-	scope = newEnclosedScope(scope)
+	scope = newInnerScope(scope)
 	p.advancePastNL()
 	p.parseBlock(scope)
 	return nil
 }
 
 //TODO: implemented
 func (p *Parser) parseWhileStatment(scope *scope) Node {
-	scope = newEnclosedScope(scope)
+	scope = newInnerScope(scope)
 	p.advancePastNL()
 	p.parseBlock(scope)
 	return nil
 }
 
 //TODO: implemented
 func (p *Parser) parseIfStatment(scope *scope) Node {
-	scope = newEnclosedScope(scope)
+	scope = newInnerScope(scope)
 	p.advancePastNL()
 	p.parseBlock(scope)
 	return nil

pkg/parser/scope.go

@@ -9,7 +9,7 @@ func newScope() *scope {
 	return &scope{vars: map[string]*Var{}}
 }
 
-func newEnclosedScope(outer *scope) *scope {
+func newInnerScope(outer *scope) *scope {
 	return &scope{vars: map[string]*Var{}, outer: outer}
 }