diff --git a/codeGeneration/src/prog8/compiler/target/cpu6502/codegen/AsmGen.kt b/codeGeneration/src/prog8/compiler/target/cpu6502/codegen/AsmGen.kt index d88b2ba51..a108e1393 100644 --- a/codeGeneration/src/prog8/compiler/target/cpu6502/codegen/AsmGen.kt +++ b/codeGeneration/src/prog8/compiler/target/cpu6502/codegen/AsmGen.kt @@ -274,7 +274,6 @@ class AsmGen(private val program: Program, && variable.datatype != DataType.FLOAT && options.zeropage != ZeropageType.DONTUSE) { try { - val errors = ErrorReporter() // TODO why not just use this.errors? then we can clean up the visibility of ErrorReporter class again too val address = zeropage.allocate(fullName, variable.datatype, null, errors) errors.report() out("${variable.name} = $address\t; auto zp ${variable.datatype}") diff --git a/codeGeneration/test/AsmGenTests.kt b/codeGeneration/test/AsmGenTests.kt index 70efdb93b..dc2711456 100644 --- a/codeGeneration/test/AsmGenTests.kt +++ b/codeGeneration/test/AsmGenTests.kt @@ -21,6 +21,7 @@ import prog8.compilerinterface.* import prog8.parser.SourceCode import prog8tests.asmgen.helpers.DummyFunctions import prog8tests.asmgen.helpers.DummyMemsizer +import prog8tests.asmgen.helpers.ErrorReporterForTests import java.nio.file.Path @@ -79,7 +80,7 @@ locallabel: } private fun createTestAsmGen(program: Program): AsmGen { - val errors = ErrorReporter() + val errors = ErrorReporterForTests() val options = CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, true, C64Target) val zp = C64MachineDefinition.C64Zeropage(options) val asmgen = AsmGen(program, errors, zp, options, C64Target, Path.of("")) diff --git a/codeGeneration/test/TestCodeGeneration.kt b/codeGeneration/test/TestCodeGeneration.kt deleted file mode 100644 index dac2f041a..000000000 --- a/codeGeneration/test/TestCodeGeneration.kt +++ /dev/null @@ -1,18 +0,0 @@ -package prog8tests.asmgen - -import org.junit.jupiter.api.Disabled -import org.junit.jupiter.api.Test -import org.junit.jupiter.api.TestInstance -import kotlin.test.fail - - -@TestInstance(TestInstance.Lifecycle.PER_CLASS) -class TestCodeGeneration { - - @Test - @Disabled("for future implementation") - fun dummy() { - fail("dummy") - } - -} diff --git a/codeGeneration/test/helpers/ErrorReporterForTests.kt b/codeGeneration/test/helpers/ErrorReporterForTests.kt new file mode 100644 index 000000000..8a775ab48 --- /dev/null +++ b/codeGeneration/test/helpers/ErrorReporterForTests.kt @@ -0,0 +1,28 @@ +package prog8tests.asmgen.helpers + +import prog8.ast.base.Position +import prog8.compilerinterface.IErrorReporter + +internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors: Boolean=true): IErrorReporter { + + + val errors = mutableListOf() + val warnings = mutableListOf() + + override fun err(msg: String, position: Position) { + errors.add("${position.toClickableStr()} $msg") + } + + override fun warn(msg: String, position: Position) { + warnings.add("${position.toClickableStr()} $msg") + } + + override fun noErrors(): Boolean = errors.isEmpty() + + override fun report() { + if(throwExceptionAtReportIfErrors) + finalizeNumErrors(errors.size, warnings.size) + errors.clear() + warnings.clear() + } +} diff --git a/compiler/src/prog8/compiler/ErrorReporter.kt b/compiler/src/prog8/compiler/ErrorReporter.kt new file mode 100644 index 000000000..ce91f17e7 --- /dev/null +++ b/compiler/src/prog8/compiler/ErrorReporter.kt @@ -0,0 +1,47 @@ +package prog8.compiler + +import prog8.ast.base.Position +import prog8.compilerinterface.IErrorReporter + +internal class ErrorReporter: IErrorReporter { + private enum class MessageSeverity { + WARNING, + ERROR + } + private class CompilerMessage(val severity: MessageSeverity, val message: String, val position: Position) + + private val messages = mutableListOf() + private val alreadyReportedMessages = mutableSetOf() + + override fun err(msg: String, position: Position) { + messages.add(CompilerMessage(MessageSeverity.ERROR, msg, position)) + } + override fun warn(msg: String, position: Position) { + messages.add(CompilerMessage(MessageSeverity.WARNING, msg, position)) + } + + override fun report() { + var numErrors = 0 + var numWarnings = 0 + messages.forEach { + when(it.severity) { + MessageSeverity.ERROR -> System.err.print("\u001b[91m") // bright red + MessageSeverity.WARNING -> System.err.print("\u001b[93m") // bright yellow + } + val msg = "${it.position.toClickableStr()} ${it.severity} ${it.message}".trim() + if(msg !in alreadyReportedMessages) { + System.err.println(msg) + alreadyReportedMessages.add(msg) + when(it.severity) { + MessageSeverity.WARNING -> numWarnings++ + MessageSeverity.ERROR -> numErrors++ + } + } + System.err.print("\u001b[0m") // reset color + } + messages.clear() + finalizeNumErrors(numErrors, numWarnings) + } + + override fun noErrors() = messages.none { it.severity==MessageSeverity.ERROR } +} diff --git a/compiler/test/TestImportedModulesOrderAndOptions.kt b/compiler/test/TestImportedModulesOrderAndOptions.kt index b2031fbd3..44a4fc0a5 100644 --- a/compiler/test/TestImportedModulesOrderAndOptions.kt +++ b/compiler/test/TestImportedModulesOrderAndOptions.kt @@ -6,9 +6,9 @@ import prog8.ast.internedStringsModuleName import prog8.compiler.determineCompilationOptions import prog8.compiler.parseImports import prog8.compiler.target.C64Target -import prog8.compilerinterface.ErrorReporter import prog8.compilerinterface.ZeropageType import prog8tests.ast.helpers.outputDir +import prog8tests.helpers.ErrorReporterForTests import prog8tests.helpers.assertSuccess import prog8tests.helpers.compileText import kotlin.test.assertEquals @@ -70,7 +70,7 @@ main { @Test fun testModuleOrderAndCompilationOptionsCorrectWithJustImports() { - val errors = ErrorReporter() + val errors = ErrorReporterForTests() val sourceText = """ %import textio %import floats diff --git a/compiler/test/ZeropageTests.kt b/compiler/test/ZeropageTests.kt index 5e9075a9d..3aece32ae 100644 --- a/compiler/test/ZeropageTests.kt +++ b/compiler/test/ZeropageTests.kt @@ -8,6 +8,7 @@ import prog8.compiler.target.Cx16Target import prog8.compiler.target.c64.C64MachineDefinition.C64Zeropage import prog8.compiler.target.cx16.CX16MachineDefinition.CX16Zeropage import prog8.compilerinterface.* +import prog8tests.helpers.ErrorReporterForTests import kotlin.test.assertEquals import kotlin.test.assertFailsWith import kotlin.test.assertFalse @@ -17,7 +18,7 @@ import kotlin.test.assertTrue @TestInstance(TestInstance.Lifecycle.PER_CLASS) class TestC64Zeropage { - private val errors = ErrorReporter() + private val errors = ErrorReporterForTests() @Test fun testNames() { @@ -216,7 +217,7 @@ class TestC64Zeropage { @TestInstance(TestInstance.Lifecycle.PER_CLASS) class TestCx16Zeropage { - private val errors = ErrorReporter() + private val errors = ErrorReporterForTests() @Test fun testReservedLocations() { diff --git a/compiler/test/helpers/ErrorReporterForTests.kt b/compiler/test/helpers/ErrorReporterForTests.kt index baa727e65..a11dc1d97 100644 --- a/compiler/test/helpers/ErrorReporterForTests.kt +++ b/compiler/test/helpers/ErrorReporterForTests.kt @@ -3,7 +3,7 @@ package prog8tests.helpers import prog8.ast.base.Position import prog8.compilerinterface.IErrorReporter -class ErrorReporterForTests(private val throwExceptionAtReportIfErrors: Boolean=true): IErrorReporter { +internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors: Boolean=true): IErrorReporter { val errors = mutableListOf() diff --git a/compiler/test/helpers/compileXyz.kt b/compiler/test/helpers/compileXyz.kt index 113ddf4d0..8fc8fe42f 100644 --- a/compiler/test/helpers/compileXyz.kt +++ b/compiler/test/helpers/compileXyz.kt @@ -2,7 +2,6 @@ package prog8tests.helpers import prog8.compiler.CompilationResult import prog8.compiler.compileProgram -import prog8.compilerinterface.ErrorReporter import prog8.compilerinterface.ICompilationTarget import prog8.compilerinterface.IErrorReporter import prog8tests.ast.helpers.assumeReadableFile @@ -46,7 +45,7 @@ internal fun compileFile( platform.name, sourceDirs = listOf(), outputDir, - errors = errors ?: ErrorReporter() + errors = errors ?: ErrorReporterForTests() ) } diff --git a/compilerInterfaces/src/prog8/compilerinterface/IErrorReporter.kt b/compilerInterfaces/src/prog8/compilerinterface/IErrorReporter.kt index daafb9dbf..e48ba51b8 100644 --- a/compilerInterfaces/src/prog8/compilerinterface/IErrorReporter.kt +++ b/compilerInterfaces/src/prog8/compilerinterface/IErrorReporter.kt @@ -15,46 +15,3 @@ interface IErrorReporter { } } - -class ErrorReporter: IErrorReporter { - private enum class MessageSeverity { - WARNING, - ERROR - } - private class CompilerMessage(val severity: MessageSeverity, val message: String, val position: Position) - - private val messages = mutableListOf() - private val alreadyReportedMessages = mutableSetOf() - - override fun err(msg: String, position: Position) { - messages.add(CompilerMessage(MessageSeverity.ERROR, msg, position)) - } - override fun warn(msg: String, position: Position) { - messages.add(CompilerMessage(MessageSeverity.WARNING, msg, position)) - } - - override fun report() { - var numErrors = 0 - var numWarnings = 0 - messages.forEach { - when(it.severity) { - MessageSeverity.ERROR -> System.err.print("\u001b[91m") // bright red - MessageSeverity.WARNING -> System.err.print("\u001b[93m") // bright yellow - } - val msg = "${it.position.toClickableStr()} ${it.severity} ${it.message}".trim() - if(msg !in alreadyReportedMessages) { - System.err.println(msg) - alreadyReportedMessages.add(msg) - when(it.severity) { - MessageSeverity.WARNING -> numWarnings++ - MessageSeverity.ERROR -> numErrors++ - } - } - System.err.print("\u001b[0m") // reset color - } - messages.clear() - finalizeNumErrors(numErrors, numWarnings) - } - - override fun noErrors() = messages.none { it.severity==MessageSeverity.ERROR } -}