cleanups

.idea/inspectionProfiles/Project_Default.xml

@@ -7,6 +7,7 @@
         <language isEnabled="false" name="Groovy" />
       </Languages>
     </inspection_tool>
+    <inspection_tool class="IncompleteDestructuring" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="PyInterpreterInspection" enabled="false" level="WARNING" enabled_by_default="false" />
     <inspection_tool class="SpellCheckingInspection" enabled="true" level="TYPO" enabled_by_default="true">
       <option name="processCode" value="false" />

codeGeneration/src/prog8/compiler/target/cpu6502/codegen/AsmGen.kt

@@ -1384,14 +1384,15 @@ $label              nop""")
 
     private fun translate(jump: Jump) {
         if(jump.isGosub) {
+            jump as GoSub
             val tgt = jump.identifier!!.targetSubroutine(program)
             if(tgt!=null && tgt.isAsmSubroutine) {
                 // no need to rescue X , this has been taken care of already
                 out("  jsr  ${getJumpTarget(jump)}")
             } else {
-                saveXbeforeCall(jump as GoSub)
+                saveXbeforeCall(jump)
                 out("  jsr  ${getJumpTarget(jump)}")
-                restoreXafterCall(jump as GoSub)
+                restoreXafterCall(jump)
             }
         }
         else

codeGeneration/src/prog8/compiler/target/cpu6502/codegen/assignment/AsmAssignment.kt

@@ -144,7 +144,7 @@ internal class AsmAssignSource(val kind: SourceStorageKind,
                 return AsmAssignSource(SourceStorageKind.LITERALNUMBER, program, asmgen, cv.type, number = cv)
 
             return when(value) {
-                is NumericLiteralValue -> AsmAssignSource(SourceStorageKind.LITERALNUMBER, program, asmgen, value.type, number = cv)
+                is NumericLiteralValue -> throw AssemblyError("should have been constant value")
                 is StringLiteralValue -> throw AssemblyError("string literal value should not occur anymore for asm generation")
                 is ArrayLiteralValue -> throw AssemblyError("array literal value should not occur anymore for asm generation")
                 is IdentifierReference -> {

codeGeneration/src/prog8/compiler/target/cpu6502/codegen/assignment/AssignmentAsmGen.kt

@@ -1660,7 +1660,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     asmgen.out("  stz  ${target.asmVarname} |  stz  ${target.asmVarname}+1")
                 }
                 TargetStorageKind.MEMORY -> {
-                    throw AssemblyError("no asm gen for assign word $word to memory ${target.memory}")
+                    throw AssemblyError("memory is bytes not words")
                 }
                 TargetStorageKind.ARRAY -> {
                     asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UWORD, CpuRegister.Y)
@@ -1759,7 +1759,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     asmgen.out("  stz  ${target.asmVarname} ")
                 }
                 TargetStorageKind.MEMORY -> {
-                    asmgen.out("  lda  #${byte.toHex()}")
+                    asmgen.out("  lda  #0")
                     storeRegisterAInMemoryAddress(target.memory!!)
                 }
                 TargetStorageKind.ARRAY -> {

compiler/src/prog8/compiler/Compiler.kt

@@ -80,8 +80,7 @@ fun compileProgram(args: CompilerArguments): CompilationResult {
 //            printProgram(program)
 
             if (args.writeAssembly) {
-                val result = writeAssembly(program, args.errors, args.outputDir, args.quietAssembler, compilationOptions)
+                when (val result = writeAssembly(program, args.errors, args.outputDir, args.quietAssembler, compilationOptions)) {
-                when (result) {
                     is WriteAssemblyResult.Ok -> programName = result.filename
                     is WriteAssemblyResult.Fail -> {
                         System.err.println(result.error)

compiler/src/prog8/compiler/ModuleImporter.kt

@@ -43,10 +43,7 @@ class ModuleImporter(private val program: Program,
         println(logMsg)
 
         val module = importModule(SourceCode.File(srcPath))
-        return if(module==null)
+        return Ok(module)
-            Err(NoSuchFileException(srcPath.toFile()))
-        else
-            Ok(module)
     }
 
     fun importLibraryModule(name: String): Module? {
@@ -56,7 +53,7 @@ class ModuleImporter(private val program: Program,
         return executeImportDirective(import, null)
     }
 
-    private fun importModule(src: SourceCode) : Module? {
+    private fun importModule(src: SourceCode) : Module {
         val moduleAst = Prog8Parser.parseModule(src)
         program.addModule(moduleAst)
 
@@ -150,7 +147,7 @@ class ModuleImporter(private val program: Program,
         locations.forEach {
             try {
                 return Ok(SourceCode.File(it.resolve(fileName)))
-            } catch (e: NoSuchFileException) {
+            } catch (_: NoSuchFileException) {
             }
         }
 

compiler/src/prog8/compiler/astprocessing/AstChecker.kt

@@ -703,7 +703,7 @@ internal class AstChecker(private val program: Program,
                     err("this directive can't be used here")
                 val errormsg = "invalid asmbinary directive, expected arguments: \"filename\" [, offset [, length ] ]"
                 if(directive.args.isEmpty()) err(errormsg)
-                else if(directive.args.isNotEmpty() && directive.args[0].str==null) err(errormsg)
+                else if(directive.args[0].str==null) err(errormsg)
                 else if(directive.args.size>=2 && directive.args[1].int==null) err(errormsg)
                 else if(directive.args.size==3 && directive.args[2].int==null) err(errormsg)
                 else if(directive.args.size>3) err(errormsg)
@@ -1216,7 +1216,7 @@ internal class AstChecker(private val program: Program,
                     val arraySpecSize = arrayspec.constIndex()
                     val arraySize = value.value.size
                     if(arraySpecSize!=null && arraySpecSize>0) {
-                        if(arraySpecSize<1 || arraySpecSize>256)
+                        if(arraySpecSize>256)
                             return err("byte array length must be 1-256")
                         val expectedSize = arrayspec.constIndex() ?: return err("array size specifier must be constant integer value")
                         if (arraySize != expectedSize)
@@ -1235,7 +1235,7 @@ internal class AstChecker(private val program: Program,
                     val arraySpecSize = arrayspec.constIndex()
                     val arraySize = value.value.size
                     if(arraySpecSize!=null && arraySpecSize>0) {
-                        if(arraySpecSize<1 || arraySpecSize>128)
+                        if(arraySpecSize>128)
                             return err("word array length must be 1-128")
                         val expectedSize = arrayspec.constIndex() ?: return err("array size specifier must be constant integer value")
                         if (arraySize != expectedSize)
@@ -1254,7 +1254,7 @@ internal class AstChecker(private val program: Program,
                     val arraySize = value.value.size
                     val arraySpecSize = arrayspec.constIndex()
                     if(arraySpecSize!=null && arraySpecSize>0) {
-                        if(arraySpecSize < 1 || arraySpecSize>51)
+                        if(arraySpecSize>51)
                             return err("float array length must be 1-51")
                         val expectedSize = arrayspec.constIndex() ?: return err("array size specifier must be constant integer value")
                         if (arraySize != expectedSize)

compiler/src/prog8/compiler/astprocessing/AstExtensions.kt

@@ -11,7 +11,6 @@ import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 import prog8.compiler.BeforeAsmGenerationAstChanger
 import prog8.compilerinterface.CompilationOptions
-import prog8.compilerinterface.ICompilationTarget
 import prog8.compilerinterface.IErrorReporter
 import prog8.compilerinterface.IStringEncoding
 

compiler/src/prog8/compiler/astprocessing/StatementReorderer.kt

@@ -8,7 +8,6 @@ import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 import prog8.compilerinterface.BuiltinFunctions
 import prog8.compilerinterface.CompilationOptions
-import prog8.compilerinterface.ICompilationTarget
 import prog8.compilerinterface.IErrorReporter
 
 

compiler/src/prog8/compiler/astprocessing/TypecastsAdder.kt

@@ -108,7 +108,7 @@ class TypecastsAdder(val program: Program, val errors: IErrorReporter) : AstWalk
                     }
                     val cvalue = assignment.value.constValue(program)
                     if(cvalue!=null) {
-                        val number = cvalue.number.toDouble()
+                        val number = cvalue.number
                         // more complex comparisons if the type is different, but the constant value is compatible
                         if (valuetype == DataType.BYTE && targettype == DataType.UBYTE) {
                             if(number>0)

compiler/test/ModuleImporterTests.kt

@@ -173,14 +173,14 @@ class TestModuleImporter: FunSpec({
                     val act = { importer.importModule(importing) }
 
                     repeat(repetitions) { n -> withClue(count[n] + " call") {
-                        shouldThrow<ParseError>() { act() }.let {
+                        shouldThrow<ParseError> { act() }.let {
                             it.position.file shouldBe SourceCode.relative(imported).toString()
                             withClue("line; should be 1-based") { it.position.line shouldBe 2 }
                             withClue("startCol; should be 0-based") { it.position.startCol shouldBe 6 }
                             withClue("endCol; should be 0-based") { it.position.endCol shouldBe 6 }
                         }
                     }
-                        withClue("imported module with error in it should not be present") { program.modules.size shouldBe 1 }
+                    withClue("imported module with error in it should not be present") { program.modules.size shouldBe 1 }
                         program.modules[0].name shouldBe internedStringsModuleName
                     }
                 }

compilerAst/src/prog8/ast/base/Base.kt

@@ -35,9 +35,6 @@ enum class DataType {
             }
 
     fun oneOf(vararg types: DataType) = this in types
-    infix fun isAssignableTo(targetTypes: Set<DataType>) = targetTypes.any { this isAssignableTo it }
-    infix fun isNotAssignableTo(targetType: DataType) = !this.isAssignableTo(targetType)
-    infix fun isNotAssignableTo(targetTypes: Set<DataType>) = !this.isAssignableTo(targetTypes)
 
     infix fun largerThan(other: DataType) =
             when {