Merge pull request #49 from noti0na1/dotty-explicit-nulls-notNull

Add predicate to check out of order for mutable variables

Author: noti0na1

.github/ISSUE_TEMPLATE/bug.md

@@ -15,5 +15,3 @@ println("hello, world")
 
 
 ## expectation
-
-

.github/ISSUE_TEMPLATE/crash.md

@@ -2,7 +2,7 @@
 name: "\U0001F4A5 Crash report"
 about: Report a Dotty Compiler compiler crash
 title: ''
-labels: itype:bug
+labels: itype:bug, itype:crash
 assignees: ''
 
 ---

.github/ISSUE_TEMPLATE/feature.md

@@ -2,12 +2,9 @@
 name: "\U0001F389 Suggest a feature"
 about: Please create a feature request here https://github.com/lampepfl/dotty-feature-requests
 title: ''
-labels:
+labels: ''
 assignees: ''
 
 ---
 
 Please create a feature request here: [lampepfl/dotty-feature-requests](https://github.com/lampepfl/dotty-feature-requests).
-
-
-

.github/ISSUE_TEMPLATE/syntax-highlight.md

@@ -1,13 +1,10 @@
 ---
-name: "Syntax highlighting"
+name: Syntax highlighting
 about: Please create a syntax highlighting issue here https://github.com/scala/vscode-scala-syntax/issues
 title: ''
-labels:
+labels: ''
 assignees: ''
 
 ---
 
 Please create a syntax highlighting issue here: [scala/vscode-scala-syntax](https://github.com/scala/vscode-scala-syntax/issues).
-
-
-

compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala

@@ -1224,23 +1224,20 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
     }
 
     /* Emit code to compare the two top-most stack values using the 'op' operator. */
-    private def genCJUMP(success: asm.Label, failure: asm.Label, op: TestOp, tk: BType, targetIfNoJump: asm.Label): Unit = {
-      if (targetIfNoJump == success) genCJUMP(failure, success, op.negate(), tk, targetIfNoJump)
+    private def genCJUMP(success: asm.Label, failure: asm.Label, op: TestOp, tk: BType, targetIfNoJump: asm.Label, negated: Boolean = false): Unit = {
+      if (targetIfNoJump == success) genCJUMP(failure, success, op.negate(), tk, targetIfNoJump, negated = !negated)
       else {
         if (tk.isIntSizedType) { // BOOL, BYTE, CHAR, SHORT, or INT
           bc.emitIF_ICMP(op, success)
         } else if (tk.isRef) { // REFERENCE(_) | ARRAY(_)
           bc.emitIF_ACMP(op, success)
         } else {
           import Primitives._
+          def useCmpG = if (negated) op == GT || op == GE else op == LT || op == LE
           (tk: @unchecked) match {
             case LONG   => emit(asm.Opcodes.LCMP)
-            case FLOAT  =>
-              if (op == LT || op == LE) emit(asm.Opcodes.FCMPL)
-              else emit(asm.Opcodes.FCMPG)
-            case DOUBLE =>
-              if (op == LT || op == LE) emit(asm.Opcodes.DCMPL)
-              else emit(asm.Opcodes.DCMPG)
+            case FLOAT  => emit(if (useCmpG) asm.Opcodes.FCMPG else asm.Opcodes.FCMPL)
+            case DOUBLE => emit(if (useCmpG) asm.Opcodes.DCMPG else asm.Opcodes.DCMPL)
           }
           bc.emitIF(op, success)
         }
@@ -1249,9 +1246,9 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
     }
 
     /* Emits code to compare (and consume) stack-top and zero using the 'op' operator */
-    private def genCZJUMP(success: asm.Label, failure: asm.Label, op: TestOp, tk: BType, targetIfNoJump: asm.Label): Unit = {
+    private def genCZJUMP(success: asm.Label, failure: asm.Label, op: TestOp, tk: BType, targetIfNoJump: asm.Label, negated: Boolean = false): Unit = {
       import Primitives._
-      if (targetIfNoJump == success) genCZJUMP(failure, success, op.negate(), tk, targetIfNoJump)
+      if (targetIfNoJump == success) genCZJUMP(failure, success, op.negate(), tk, targetIfNoJump, negated = !negated)
       else {
         if (tk.isIntSizedType) { // BOOL, BYTE, CHAR, SHORT, or INT
           bc.emitIF(op, success)
@@ -1261,18 +1258,17 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
             case NE => bc emitIFNONNULL success
           }
         } else {
+          def useCmpG = if (negated) op == GT || op == GE else op == LT || op == LE
           (tk: @unchecked) match {
             case LONG   =>
               emit(asm.Opcodes.LCONST_0)
               emit(asm.Opcodes.LCMP)
             case FLOAT  =>
               emit(asm.Opcodes.FCONST_0)
-              if (op == LT || op == LE) emit(asm.Opcodes.FCMPL)
-              else emit(asm.Opcodes.FCMPG)
+              emit(if (useCmpG) asm.Opcodes.FCMPG else asm.Opcodes.FCMPL)
             case DOUBLE =>
               emit(asm.Opcodes.DCONST_0)
-              if (op == LT || op == LE) emit(asm.Opcodes.DCMPL)
-              else emit(asm.Opcodes.DCMPG)
+              emit(if (useCmpG) asm.Opcodes.DCMPG else asm.Opcodes.DCMPL)
           }
           bc.emitIF(op, success)
         }
@@ -1287,8 +1283,8 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
        case ScalaPrimitivesOps.NE => Primitives.NE
        case ScalaPrimitivesOps.LT => Primitives.LT
        case ScalaPrimitivesOps.LE => Primitives.LE
-       case ScalaPrimitivesOps.GE => Primitives.GE
        case ScalaPrimitivesOps.GT => Primitives.GT
+       case ScalaPrimitivesOps.GE => Primitives.GE
      }
 
     /*

compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala

@@ -76,7 +76,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
 
     override def getCurrentCUnit(): CompilationUnit = { cunit }
 
-    /* ---------------- helper utils for generating classes and fiels ---------------- */
+    /* ---------------- helper utils for generating classes and fields ---------------- */
 
     def genPlainClass(cd: ClassDef) = cd match {
       case ClassDef(_, _, _, impl) =>

compiler/src/dotty/tools/backend/jvm/BCodeSyncAndTry.scala

@@ -310,7 +310,7 @@ trait BCodeSyncAndTry extends BCodeBodyBuilder {
        * ------
        */
 
-      // a note on terminology: this is not "postHandlers", despite appearences.
+      // a note on terminology: this is not "postHandlers", despite appearances.
       // "postHandlers" as in the source-code view. And from that perspective, both (3.A) and (3.B) are invisible implementation artifacts.
       if (hasFinally) withFreshCleanupScope {
         nopIfNeeded(startTryBody)

compiler/src/dotty/tools/backend/jvm/BTypes.scala

@@ -362,7 +362,7 @@ abstract class BTypes {
    *
    *  - Initializer block (JLS 8.6 / 8.7): block of statements in a java class
    *    - static initializer: executed before constructor body
-   *    - instance initializer: exectued when class is initialized (instance creation, static
+   *    - instance initializer: executed when class is initialized (instance creation, static
    *      field access, ...)
    *
    *  - A static nested class can be defined as

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -83,9 +83,14 @@ object CompilationUnit {
     unit1
   }
 
-  def apply(source: SourceFile)(implicit ctx: Context): CompilationUnit = {
+  /** Create a compilation unit corresponding to `source`.
+   *  If `mustExist` is true, this will fail if `source` does not exist.
+   */
+  def apply(source: SourceFile, mustExist: Boolean = true)(implicit ctx: Context): CompilationUnit = {
     val src =
-      if (source.file.isDirectory) {
+      if (!mustExist)
+        source
+      else if (source.file.isDirectory) {
         ctx.error(s"expected file, received directory '${source.file.path}'")
         NoSource
       }

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -804,6 +804,26 @@ object desugar {
     flatTree(cdef1 :: companions ::: implicitWrappers)
   }.reporting(i"desugared: $result", Printers.desugar)
 
+  /** Expand
+   *
+   *    package object name { body }
+   *
+   *  to:
+   *
+   *    package name {
+   *      object `package` { body }
+   *    }
+   */
+  def packageModuleDef(mdef: ModuleDef)(implicit ctx: Context): Tree =
+    val impl = mdef.impl
+    val mods = mdef.mods
+    val moduleName = normalizeName(mdef, impl).asTermName
+    if (mods.is(Package))
+      PackageDef(Ident(moduleName),
+        cpy.ModuleDef(mdef)(nme.PACKAGE, impl).withMods(mods &~ Package) :: Nil)
+    else
+      mdef
+
   /** Expand
    *
    *    object name extends parents { self => body }
@@ -854,7 +874,7 @@ object desugar {
       ctx.warning(em"${hl("final")} modifier is redundant for objects", flagSourcePos(Final))
 
     if (mods.is(Package))
-      PackageDef(Ident(moduleName), cpy.ModuleDef(mdef)(nme.PACKAGE, impl).withMods(mods &~ Package) :: Nil)
+      packageModuleDef(mdef)
     else if (isEnumCase) {
       typeParamIsReferenced(enumClass.typeParams, Nil, Nil, impl.parents)
         // used to check there are no illegal references to enum's type parameters in parents
@@ -1229,12 +1249,6 @@ object desugar {
     case _ =>
       false
 
-  /** Does this package contains at least one top-level definition
-   *  that will require a wrapping object ?
-   */
-  def hasTopLevelDef(pdef: PackageDef)(given Context): Boolean =
-    pdef.stats.exists(isTopLevelDef)
-
   /** Assuming `src` contains top-level definition, returns the name that should
    *  be using for the package object that will wrap them.
    */
@@ -1758,7 +1772,7 @@ object desugar {
       case Block(Nil, expr) =>
         collect(expr)
       case Quote(expr) =>
-        new TreeTraverser {
+        new UntypedTreeTraverser {
           def traverse(tree: untpd.Tree)(implicit ctx: Context): Unit = tree match {
             case Splice(expr) => collect(expr)
             case TypSplice(expr) =>