Fixed compiler warning in Scanner

src/main/fr/celticinfo/lox/Lox.kt

@@ -23,7 +23,7 @@ class Lox {
             print("> ")
             val line = readlnOrNull() ?: break
             run(line)
-            hadError = false;
+            hadError = false
         }
     }
 
@@ -48,7 +48,7 @@ class Lox {
             report(line, "", s)
         }
 
-        private fun report(line: Int, where: String, message: String) {
+        fun report(line: Int, where: String, message: String) {
             System.err.println("[line $line] Error$where: $message")
         }
     }

src/main/fr/celticinfo/lox/Scanner.kt

@@ -13,17 +13,12 @@ import fr.celticinfo.lox.TokenType.*
  * @property current The current index in the source code.
  * @property line The current line number in the source code.
  */
-class Scanner {
+class Scanner(private val source: String) {
-    private val source: String
     private val tokens: MutableList<Token> = mutableListOf()
     private var start = 0
     private var current = 0
     private var line = 1
 
-    constructor(source: String) {
-        this.source = source
-    }
-
     fun scanTokens(): List<Token> {
         while (!isAtEnd()) {
             // We are at the beginning of the next lexeme.
@@ -31,7 +26,7 @@ class Scanner {
             scanToken()
         }
 
-        tokens.add(Token(TokenType.EOF, "", null, line))
+        tokens.add(Token(EOF, "", null, line))
         return tokens
     }
 
@@ -113,7 +108,7 @@ class Scanner {
             return
         }
 
-        // The closing ".
+        // The closing '"'.
         advance()
 
         // Trim the surrounding quotes.

src/test/fr/celticinfo/lox/TokenTest.kt

@@ -2,15 +2,17 @@ package fr.celticinfo.lox
 
 import org.junit.jupiter.api.Test
 import kotlin.test.*
+import fr.celticinfo.lox.TokenType.*
+
 
 class TokenTest {
 
     @Test
     fun testToString() {
-        val token = Token(TokenType.IDENTIFIER, "foo", null, 1)
+        val token = Token(IDENTIFIER, "foo", null, 1)
         assertEquals("IDENTIFIER foo null 1", token.toString())
 
-        val token2 = Token(TokenType.STRING, "bar", "baz", 2)
+        val token2 = Token(STRING, "bar", "baz", 2)
         assertEquals("STRING bar baz 2", token2.toString())
     }
 }

src/test/fr/celticinfo/lox/TokenTypeTest.kt

@@ -2,55 +2,57 @@ package fr.celticinfo.lox
 
 import org.junit.jupiter.api.Test
 import kotlin.test.*
+import fr.celticinfo.lox.TokenType.*
 
 class TokenTypeTest {
 
     @Test
     fun `TokenType contains expected values`() {
-        assertTrue(TokenType.values().contains(TokenType.LEFT_PAREN))
+        val tokenTypeEntries = TokenType.entries.toTypedArray()
-        assertTrue(TokenType.values().contains(TokenType.RIGHT_PAREN))
+        assertTrue(tokenTypeEntries.contains(LEFT_PAREN))
-        assertTrue(TokenType.values().contains(TokenType.LEFT_BRACE))
+        assertTrue(tokenTypeEntries.contains(RIGHT_PAREN))
-        assertTrue(TokenType.values().contains(TokenType.RIGHT_BRACE))
+        assertTrue(tokenTypeEntries.contains(LEFT_BRACE))
-        assertTrue(TokenType.values().contains(TokenType.COMMA))
+        assertTrue(tokenTypeEntries.contains(RIGHT_BRACE))
-        assertTrue(TokenType.values().contains(TokenType.DOT))
+        assertTrue(tokenTypeEntries.contains(COMMA))
-        assertTrue(TokenType.values().contains(TokenType.MINUS))
+        assertTrue(tokenTypeEntries.contains(DOT))
-        assertTrue(TokenType.values().contains(TokenType.PLUS))
+        assertTrue(tokenTypeEntries.contains(MINUS))
-        assertTrue(TokenType.values().contains(TokenType.SEMICOLON))
+        assertTrue(tokenTypeEntries.contains(PLUS))
-        assertTrue(TokenType.values().contains(TokenType.SLASH))
+        assertTrue(tokenTypeEntries.contains(SEMICOLON))
-        assertTrue(TokenType.values().contains(TokenType.STAR))
+        assertTrue(tokenTypeEntries.contains(SLASH))
-
+        assertTrue(tokenTypeEntries.contains(STAR))
-        assertTrue(TokenType.values().contains(TokenType.BANG))
+
-        assertTrue(TokenType.values().contains(TokenType.BANG_EQUAL))
+        assertTrue(tokenTypeEntries.contains(BANG))
-        assertTrue(TokenType.values().contains(TokenType.EQUAL))
+        assertTrue(tokenTypeEntries.contains(BANG_EQUAL))
-        assertTrue(TokenType.values().contains(TokenType.EQUAL_EQUAL))
+        assertTrue(tokenTypeEntries.contains(EQUAL))
-        assertTrue(TokenType.values().contains(TokenType.GREATER))
+        assertTrue(tokenTypeEntries.contains(EQUAL_EQUAL))
-        assertTrue(TokenType.values().contains(TokenType.GREATER_EQUAL))
+        assertTrue(tokenTypeEntries.contains(GREATER))
-        assertTrue(TokenType.values().contains(TokenType.LESS))
+        assertTrue(tokenTypeEntries.contains(GREATER_EQUAL))
-        assertTrue(TokenType.values().contains(TokenType.LESS_EQUAL))
+        assertTrue(tokenTypeEntries.contains(LESS))
-
+        assertTrue(tokenTypeEntries.contains(LESS_EQUAL))
-        assertTrue(TokenType.values().contains(TokenType.IDENTIFIER))
+
-        assertTrue(TokenType.values().contains(TokenType.STRING))
+        assertTrue(tokenTypeEntries.contains(IDENTIFIER))
-        assertTrue(TokenType.values().contains(TokenType.NUMBER))
+        assertTrue(tokenTypeEntries.contains(STRING))
-
+        assertTrue(tokenTypeEntries.contains(NUMBER))
-        assertTrue(TokenType.values().contains(TokenType.AND))
+
-        assertTrue(TokenType.values().contains(TokenType.CLASS))
+        assertTrue(tokenTypeEntries.contains(AND))
-        assertTrue(TokenType.values().contains(TokenType.ELSE))
+        assertTrue(tokenTypeEntries.contains(CLASS))
-        assertTrue(TokenType.values().contains(TokenType.FALSE))
+        assertTrue(tokenTypeEntries.contains(ELSE))
-        assertTrue(TokenType.values().contains(TokenType.FUN))
+        assertTrue(tokenTypeEntries.contains(FALSE))
-        assertTrue(TokenType.values().contains(TokenType.FOR))
+        assertTrue(tokenTypeEntries.contains(FUN))
-        assertTrue(TokenType.values().contains(TokenType.IF))
+        assertTrue(tokenTypeEntries.contains(FOR))
-        assertTrue(TokenType.values().contains(TokenType.NIL))
+        assertTrue(tokenTypeEntries.contains(IF))
-        assertTrue(TokenType.values().contains(TokenType.OR))
+        assertTrue(tokenTypeEntries.contains(NIL))
-        assertTrue(TokenType.values().contains(TokenType.PRINT))
+        assertTrue(tokenTypeEntries.contains(OR))
-        assertTrue(TokenType.values().contains(TokenType.RETURN))
+        assertTrue(tokenTypeEntries.contains(PRINT))
-        assertTrue(TokenType.values().contains(TokenType.SUPER))
+        assertTrue(tokenTypeEntries.contains(RETURN))
-        assertTrue(TokenType.values().contains(TokenType.THIS))
+        assertTrue(tokenTypeEntries.contains(SUPER))
-        assertTrue(TokenType.values().contains(TokenType.TRUE))
+        assertTrue(tokenTypeEntries.contains(THIS))
-        assertTrue(TokenType.values().contains(TokenType.VAR))
+        assertTrue(tokenTypeEntries.contains(TRUE))
-        assertTrue(TokenType.values().contains(TokenType.WHILE))
+        assertTrue(tokenTypeEntries.contains(VAR))
-
+        assertTrue(tokenTypeEntries.contains(WHILE))
-        assertTrue(TokenType.values().contains(TokenType.EOF))
+
-
+        assertTrue(tokenTypeEntries.contains(EOF))
-        assertEquals(39, TokenType.values().size)
+
+        assertEquals(39, tokenTypeEntries.size)
     }
 }