updated lexer to hold keyword name

Author: umangshrestha

src/main/java/com/example/ast/Expr.java

@@ -136,14 +136,14 @@ public String toString() {
     @Getter
     @AllArgsConstructor
     public static class This extends Expr {
-        private final Token keyword;
+        private final Token name;
 
         public Object accept(ExprVisitor v) {
             return v.visitThisExpr(this);
         }
 
         public String toString() {
-            return String.format("this.%s", keyword.getLiteral());
+            return String.format("this");
         }
     }
 

src/main/java/com/example/environment/Resolver.java

@@ -225,8 +225,8 @@ else if (currentClass != ClassType.SUBCLASS)
     @Override
     public Object visitThisExpr(This expr) {
         if (currentClass == ClassType.NONE)
-            throw new RuntimeError("Cannot use 'this' outside of a class.", expr.getKeyword());
-        resolveLocal(expr, expr.getKeyword());
+            throw new RuntimeError("Cannot use 'this' outside of a class.", expr.getName());
+        resolveLocal(expr, expr.getName());
         return null;
     }
 

src/main/java/com/example/interpreter/CustomFunction.java

@@ -7,19 +7,19 @@
 
 public class CustomFunction implements CustomCallable {
     Environment closure;
-    Boolean isInitializer = false;
+    Boolean isConstructor = false;
     Stmt.Function declaration;
 
-    CustomFunction(Stmt.Function declaration, Environment closure, Boolean isInitializer) {
+    CustomFunction(Stmt.Function declaration, Environment closure, Boolean isConstructor) {
         this.closure = closure;
-        this.isInitializer = isInitializer;
+        this.isConstructor = isConstructor;
         this.declaration = declaration;
     }
 
     CustomFunction bind(CustomInstance instance) {
         Environment environment = new Environment(closure);
         environment.define("this", instance);
-        return new CustomFunction(declaration, environment, isInitializer);
+        return new CustomFunction(declaration, environment, isConstructor);
     }
 
     @Override
@@ -40,20 +40,17 @@ public Object call(Interpreter interpreter, List<Object> arguments) {
                     declaration.getBody().getStmts(),
                     environment);
         } catch (CustomError.Return returnValue) {
-            if (isInitializer) {
-                return closure.getAt(0, "this");
-            }
             return returnValue.getValue();
         }
-        if (isInitializer) {
+        if (isConstructor) {
             return closure.getAt(0, "this");
         }
         return null;
     }
 
     @Override
     public String toString() {
-        return "<fn:\"" + declaration.getName().getLiteral() + "\">";
+        return String.format("<fn:\"%s\">", declaration.getName());
     }
 
 }

src/main/java/com/example/interpreter/CustomInstance.java

@@ -29,4 +29,9 @@ Object get(Token name) {
     void set(Token name, Object value) {
         fields.put((String) name.getLiteral(), value);
     }
+
+    @Override
+    public String toString() {
+        return String.format("<instance:\"%s>", customClass);
+    }
 }

src/main/java/com/example/interpreter/Interpreter.java

@@ -260,12 +260,13 @@ public void visitClassStmt(Class stmt) {
         }
         Map<String, CustomFunction> methods = new HashMap<>();
         for (Stmt.Function method : stmt.getMethods()) {
+            String className = (String) method.getName().getLiteral();
             methods.put(
-                    (String) method.getName().getLiteral(),
+                    className,
                     new CustomFunction(
                             method,
                             environment,
-                            method.getName().getLiteral().equals("init")));
+                            className.equals(CustomClass.constructor)));
         }
         CustomClass klass = new CustomClass(
                 (String) stmt.getName().getLiteral(),
@@ -299,7 +300,8 @@ public Object visitCallExpr(Call expr) {
         if (function.arity() == -1 || function.arity() == arguments.size()) {
             return function.call(this, arguments);
         }
-        throw new RuntimeError("Expected " + function.arity() + " arguments but got " + arguments.size(),
+        throw new RuntimeError(
+                String.format("Expected %s arguments, but got %s", function.arity(), arguments.size()),
                 expr.getParen());
     }
 
@@ -339,7 +341,7 @@ public Object visitSuperExpr(Super expr) {
 
     @Override
     public Object visitThisExpr(This expr) {
-        return lookUpVariable(expr.getKeyword(), expr);
+        return lookUpVariable(expr.getName(), expr);
     }
 
     private Object lookUpVariable(Token name, Expr expr) {

src/main/java/com/example/lexer/Lexer.java

@@ -233,8 +233,8 @@ private Token identifier() {
         String text = new String(input, start, pos - start);
         TokenType type = keywords.get(text);
         if (type == null)
-            return new Token(TokenType.Identifier, line, col, text);
-        return new Token(type, line, col);
+            type = TokenType.Identifier;
+        return new Token(type, line, col, text);
     }
 
     private void removeComment() {

src/test/java/com/example/lexer/LexerKeywordTest.java

@@ -0,0 +1,55 @@
+package com.example.lexer;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import com.example.token.Token;
+import com.example.token.TokenType;
+
+@RunWith(Parameterized.class)
+public class LexerKeywordTest {
+    private String input;
+    private TokenType expectedType;
+
+    @Parameterized.Parameters
+    public static Collection<Object[]> data() {
+        return Arrays.asList(new Object[][] {
+                { "true", TokenType.True },
+                { "false", TokenType.False },
+                { "null", TokenType.Null },
+                { "for", TokenType.For },
+                { "while", TokenType.While },
+                { "this", TokenType.This },
+                { "super", TokenType.Super },
+                { "return", TokenType.Return },
+                { "fn", TokenType.Function },
+
+        });
+    }
+
+    public LexerKeywordTest(String input, TokenType expectedType) {
+        this.input = input;
+        this.expectedType = expectedType;
+    }
+
+    @Test
+    public void testSingleToken() {
+        Token expected = new Token(expectedType, 1, 1, input);
+        Lexer l = new Lexer(input);
+        try {
+            Token tok = l.next();
+            assertEquals(tok, expected);
+
+            tok = new Token(TokenType.Eof, 1, input.length() + 1);
+        } catch (LexerError e) {
+            fail(e.getMessage());
+        }
+    }
+}

src/test/java/com/example/lexer/LexerObject.java

@@ -22,9 +22,9 @@ public static List<Object[]> data() {
         return Arrays.asList(new Object[][] {
                 { "1", new Token(TokenType.Number, 1, 1, 1.0) },
                 { "1.0", new Token(TokenType.Number, 1, 1, 1.0) },
-                { "true", new Token(TokenType.True, 1, 1, null) },
-                { "false", new Token(TokenType.False, 1, 1, null) },
-                { "null", new Token(TokenType.Null, 1, 1, null) },
+                { "true", new Token(TokenType.True, 1, 1, "true") },
+                { "false", new Token(TokenType.False, 1, 1, "false") },
+                { "null", new Token(TokenType.Null, 1, 1, "null") },
         });
     }
 

src/test/java/com/example/lexer/LexerTest.java

@@ -51,16 +51,6 @@ public static Collection<Object[]> data() {
                 { "*=", TokenType.MultiplyAssign },
                 { "^=", TokenType.ExponentAssign },
                 { "!=", TokenType.NotEqual },
-                { "for", TokenType.For },
-                { "while", TokenType.While },
-                { "fn", TokenType.Function },
-                { "let", TokenType.Let },
-                { "if", TokenType.If },
-                { "else", TokenType.Else },
-                { "return", TokenType.Return },
-                { "class", TokenType.Class },
-                { "break", TokenType.Break },
-                { "continue", TokenType.Continue }
         });
     }