Merge branch 'main' into en-migrate-main

noti0na1 · web-flow · commit a393925f3bb9 · 2022-02-19T16:21:01.000-05:00
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -351,7 +351,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
       else parents
     val cls = newNormalizedClassSymbol(owner, tpnme.ANON_CLASS, Synthetic | Final, parents1,
-        newScope, coord = fns.map(_.span).reduceLeft(_ union _))
+        coord = fns.map(_.span).reduceLeft(_ union _))
     val constr = newConstructor(cls, Synthetic, Nil, Nil).entered
     def forwarder(fn: TermSymbol, name: TermName) = {
       val fwdMeth = fn.copy(cls, name, Synthetic | Method | Final).entered.asTerm
diff --git a/compiler/src/dotty/tools/dotc/core/Contexts.scala b/compiler/src/dotty/tools/dotc/core/Contexts.scala
@@ -714,6 +714,9 @@ object Contexts {
 
       def withNotNullInfos(infos: List[NotNullInfo]): Context =
         if c.notNullInfos eq infos then c else c.fresh.setNotNullInfos(infos)
+
+      def relaxedOverrideContext: Context =
+        c.withModeBits(c.mode &~ Mode.SafeNulls | Mode.RelaxedOverriding)
   end ops
 
   // TODO: Fix issue when converting ModeChanges and FreshModeChanges to extension givens
diff --git a/compiler/src/dotty/tools/dotc/core/Symbols.scala b/compiler/src/dotty/tools/dotc/core/Symbols.scala
@@ -567,7 +567,6 @@ object Symbols {
       name: TypeName,
       flags: FlagSet,
       parentTypes: List[Type],
-      decls: Scope,
       selfInfo: Type = NoType,
       privateWithin: Symbol = NoSymbol,
       coord: Coord = NoCoord,
diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -786,7 +786,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
               case AndType(tp1, tp2) => isNullable(tp1) && isNullable(tp2)
               case OrType(tp1, tp2) => isNullable(tp1) || isNullable(tp2)
               case _ => false
-              
+
             val sym1 = tp1.symbol
             (sym1 eq NothingClass) && tp2.isValueTypeOrLambda ||
             (sym1 eq NullClass) && isNullable(tp2)
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -1115,9 +1115,7 @@ object Types {
      */
     def matches(that: Type)(using Context): Boolean = {
       record("matches")
-      val overrideCtx = if ctx.explicitNulls
-        then ctx.retractMode(Mode.SafeNulls).addMode(Mode.RelaxedOverriding)
-        else ctx
+      val overrideCtx = if ctx.explicitNulls then ctx.relaxedOverrideContext else ctx
       TypeComparer.matchesType(this, that, relaxed = !ctx.phase.erasedTypes)(using overrideCtx)
     }
 
diff --git a/compiler/src/dotty/tools/dotc/parsing/Scanners.scala b/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
@@ -265,7 +265,7 @@ object Scanners {
     val next = newTokenData
     private val prev = newTokenData
 
-    /** The current region. This is initially an Indented region with indentation width. */
+    /** The current region. This is initially an Indented region with zero indentation width. */
     var currentRegion: Region = Indented(IndentWidth.Zero, Set(), EMPTY, null)
 
 // Get next token ------------------------------------------------------------
@@ -434,8 +434,8 @@ object Scanners {
       && !migrateTo3
       && !noindentSyntax
 
-    /** The indentation width of the given offset */
-    def indentWidth(offset: Offset): IndentWidth = {
+    /** The indentation width of the given offset. */
+    def indentWidth(offset: Offset): IndentWidth =
       import IndentWidth.{Run, Conc}
       def recur(idx: Int, ch: Char, n: Int, k: IndentWidth => IndentWidth): IndentWidth =
         if (idx < 0) k(Run(ch, n))
@@ -452,7 +452,7 @@ object Scanners {
           else recur(idx - 1, ' ', 0, identity)
         }
       recur(offset - 1, ' ', 0, identity)
-    }
+    end indentWidth
 
     /** Handle newlines, possibly inserting an INDENT, OUTDENT, NEWLINE, or NEWLINES token
      *  in front of the current token. This depends on whether indentation is significant or not.
@@ -521,6 +521,7 @@ object Scanners {
           lastWidth = r.width
           newlineIsSeparating = lastWidth <= nextWidth || r.isOutermost
           indentPrefix = r.prefix
+        case _: InString => ()
         case r =>
           indentIsSignificant = indentSyntax
           r.proposeKnownWidth(nextWidth, lastToken)
@@ -1422,7 +1423,7 @@ object Scanners {
     nextToken()
     currentRegion = topLevelRegion(indentWidth(offset))
   }
-  // end Scanner
+  end Scanner
 
   /** A Region indicates what encloses the current token. It can be one of the following
    *
diff --git a/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala b/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala
@@ -129,7 +129,7 @@ class ExpandSAMs extends MiniPhase:
     val parents = List(
       defn.AbstractPartialFunctionClass.typeRef.appliedTo(anonTpe.firstParamTypes.head, anonTpe.resultType),
       defn.SerializableType)
-    val pfSym = newNormalizedClassSymbol(anonSym.owner, tpnme.ANON_CLASS, Synthetic | Final, parents, newScope, coord = tree.span)
+    val pfSym = newNormalizedClassSymbol(anonSym.owner, tpnme.ANON_CLASS, Synthetic | Final, parents, coord = tree.span)
 
     def overrideSym(sym: Symbol) = sym.copy(
       owner = pfSym,
diff --git a/compiler/src/dotty/tools/dotc/transform/OverridingPairs.scala b/compiler/src/dotty/tools/dotc/transform/OverridingPairs.scala
@@ -221,7 +221,7 @@ object OverridingPairs:
       // releaxed override check for explicit nulls if one of the symbols is Java defined,
       // force `Null` to be a subtype of non-primitive value types during override checking.
       val overrideCtx = if ctx.explicitNulls && (member.is(JavaDefined) || other.is(JavaDefined))
-        then ctx.retractMode(Mode.SafeNulls).addMode(Mode.RelaxedOverriding) else ctx
+        then ctx.relaxedOverrideContext else ctx
       member.name.is(DefaultGetterName) // default getters are not checked for compatibility
       || memberTp.overrides(otherTp,
             member.matchNullaryLoosely || other.matchNullaryLoosely || fallBack
diff --git a/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala b/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala
@@ -114,10 +114,10 @@ object ResolveSuper {
         val otherTp = other.asSeenFrom(base.typeRef).info
         val accTp = acc.asSeenFrom(base.typeRef).info
         // Since the super class can be Java defined,
-        // we use releaxed overriding check for explicit nulls if one of the symbols is Java defined.
+        // we use relaxed overriding check for explicit nulls if one of the symbols is Java defined.
         // This forces `Null` to be a subtype of non-primitive value types during override checking.
         val overrideCtx = if ctx.explicitNulls && (sym.is(JavaDefined) || acc.is(JavaDefined))
-          then ctx.retractMode(Mode.SafeNulls).addMode(Mode.RelaxedOverriding) else ctx
+          then ctx.relaxedOverrideContext else ctx
         if !otherTp.overrides(accTp, matchLoosely = true)(using overrideCtx) then
           report.error(IllegalSuperAccessor(base, memberName, targetName, acc, accTp, other.symbol, otherTp), base.srcPos)
       bcs = bcs.tail
diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -332,12 +332,6 @@ class SpaceEngine(using Context) extends SpaceLogic {
 
   private val constantNullType     = ConstantType(Constant(null))
 
-  /** Does the given tree stand for the literal `null`? */
-  def isNullLit(tree: Tree): Boolean = tree match {
-    case Literal(Constant(null)) => true
-    case _ => false
-  }
-
   override def intersectUnrelatedAtomicTypes(tp1: Type, tp2: Type): Space = trace(s"atomic intersection: ${AndType(tp1, tp2).show}", debug) {
     // Precondition: !isSubType(tp1, tp2) && !isSubType(tp2, tp1).
     if !ctx.mode.is(Mode.SafeNulls) && (tp1.isNullType || tp2.isNullType) then
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -1802,7 +1802,7 @@ final class SearchRoot extends SearchHistory:
             // }
 
             val parents = List(defn.ObjectType, defn.SerializableType)
-            val classSym = newNormalizedClassSymbol(ctx.owner, LazyImplicitName.fresh().toTypeName, Synthetic | Final, parents, newScope, coord = span)
+            val classSym = newNormalizedClassSymbol(ctx.owner, LazyImplicitName.fresh().toTypeName, Synthetic | Final, parents, coord = span)
             val vsyms = pruned.map(_._1.symbol)
             val nsyms = vsyms.map(vsym => newSymbol(classSym, vsym.name, EmptyFlags, vsym.info, coord = span).entered)
             val vsymMap = (vsyms zip nsyms).toMap
diff --git a/compiler/src/dotty/tools/dotc/typer/Inliner.scala b/compiler/src/dotty/tools/dotc/typer/Inliner.scala
@@ -201,7 +201,7 @@ object Inliner {
 
     val UnApply(fun, implicits, patterns) = unapp
     val sym = unapp.symbol
-    val cls = newNormalizedClassSymbol(ctx.owner, tpnme.ANON_CLASS, Synthetic | Final, List(defn.ObjectType), newScope, coord = sym.coord)
+    val cls = newNormalizedClassSymbol(ctx.owner, tpnme.ANON_CLASS, Synthetic | Final, List(defn.ObjectType), coord = sym.coord)
     val constr = newConstructor(cls, Synthetic, Nil, Nil, coord = sym.coord).entered
 
     val targs = fun match
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -247,6 +247,7 @@ class CompilationTests {
     aggregateTests(
       compileFilesInDir("tests/explicit-nulls/pos", explicitNullsOptions),
       compileFilesInDir("tests/explicit-nulls/pos-separate", explicitNullsOptions),
+      compileFilesInDir("tests/explicit-nulls/pos-patmat", explicitNullsOptions and "-Xfatal-warnings"),
       compileFilesInDir("tests/explicit-nulls/unsafe-common", explicitNullsOptions and "-language:unsafeNulls"),
     )
   }.checkCompile()
diff --git a/tests/explicit-nulls/neg-patmat/match-pat.scala b/tests/explicit-nulls/neg-patmat/match-pat.scala
@@ -1,12 +1,9 @@
 class Foo {
+
   val s: String = ???
-  s match {
-    case s: String => 100 // warning: type test will always succeed
-    case _ => 200 // error: unreachable
-  }
 
   s match {
-    case s: String => 100 // warning: type test will always succeed
+    case s: String => 100
     case _ => 200 // error: unreachable
   }
 
@@ -15,20 +12,23 @@ class Foo {
   case object Cat extends Animal
 
   val a: Animal = ???
+
   a match {
     case Dog(name) => 100
     case Cat => 200
     case _ => 300 // error: unreachable
   }
 
-  val a2: Animal|Null = ???
+  val a2: Animal | Null = ???
+
   a2 match {
     case Dog(_) => 100
     case Cat => 200
     case _ => 300
   }
 
-  val a3: Animal|Null = ???
+  val a3: Animal | Null = ???
+
   a3 match {
     case Dog(_) => 100
     case Cat => 200
diff --git a/tests/explicit-nulls/neg/opaque-nullable.scala b/tests/explicit-nulls/neg/opaque-nullable.scala
@@ -0,0 +1,47 @@
+// Unboxed option type using unions + null + opaque.
+// Relies on the fact that Null is not a subtype of AnyRef.
+// Test suggested by Sébastien Doeraene.
+
+object Nullables {
+  opaque type Nullable[+A <: AnyRef] = A | Null // disjoint by construction!
+
+  object Nullable:
+    def apply[A <: AnyRef](x: A | Null): Nullable[A] = x
+
+    def some[A <: AnyRef](x: A): Nullable[A] = x
+    def none: Nullable[Nothing] = null
+
+  extension [A <: AnyRef](x: Nullable[A])
+    def isEmpty: Boolean = x == null
+    def get: A | Null = x
+
+  extension [A <: AnyRef, B <: AnyRef](x: Nullable[A])
+    def flatMap(f: A => Nullable[B]): Nullable[B] =
+      if (x == null) null
+      else f(x)
+
+    def map(f: A => B): Nullable[B] = x.flatMap(f)
+
+  def test1 =
+    val s1: Nullable[String] = Nullable("hello")
+    val s2: Nullable[String] = "world"
+    val s3: Nullable[String] = Nullable.none
+    val s4: Nullable[String] = null
+
+    s1.isEmpty
+    s1.flatMap((x) => true)
+
+    assert(s2 != null)
+}
+
+def test2 =
+  import Nullables._
+
+  val s1: Nullable[String] = Nullable("hello")
+  val s2: Nullable[String] = Nullable.none
+  val s3: Nullable[String] = null // error: don't leak nullable union
+
+  s1.isEmpty
+  s1.flatMap((x) => Nullable(true))
+
+  assert(s2 == null) // error
diff --git a/tests/explicit-nulls/pos-patmat/unsafe-match-null-pat.scala b/tests/explicit-nulls/pos-patmat/unsafe-match-null-pat.scala
@@ -0,0 +1,14 @@
+import scala.language.unsafeNulls
+
+def test1 =
+  val s: String = ???
+  s match
+    case _: String =>
+    // under unsafeNulls, we should not get Match case Unreachable Warning
+    case null => // ok
+
+def test2 =
+  val s: String | Null = ???
+  s match
+    case _: String =>
+    case null =>
diff --git a/tests/explicit-nulls/pos/opaque-nullable.scala b/tests/explicit-nulls/pos/opaque-nullable.scala
diff --git a/tests/explicit-nulls/pos/override-type-params.scala b/tests/explicit-nulls/pos/override-type-params.scala
@@ -0,0 +1,18 @@
+// Testing relaxed overriding check for explicit nulls.
+// The relaxed check is only enabled if one of the members is Java defined.
+
+import java.util.Comparator
+
+class C1[T <: AnyRef] extends Ordering[T]:
+  override def compare(o1: T, o2: T): Int = 0
+
+// The following overriding is not allowed, because `compare`
+// has already been declared in Scala class `Ordering`.
+// class C2[T <: AnyRef] extends Ordering[T]:
+//   override def compare(o1: T | Null, o2: T | Null): Int = 0
+
+class D1[T <: AnyRef] extends Comparator[T]:
+  override def compare(o1: T, o2: T): Int = 0
+
+class D2[T <: AnyRef] extends Comparator[T]:
+  override def compare(o1: T | Null, o2: T | Null): Int = 0
diff --git a/tests/explicit-nulls/unsafe-common/unsafe-match-null.scala b/tests/explicit-nulls/unsafe-common/unsafe-match-null.scala
@@ -0,0 +1,11 @@
+def test1 =
+  val s: String = ???
+  s match
+    case _: String =>
+    case null => // error: Values of types Null and String cannot be compared
+
+def test2 =
+  val s: String | Null = ???
+  s match
+    case _: String =>
+    case null =>
diff --git a/tests/neg/i14386.scala b/tests/neg/i14386.scala
@@ -0,0 +1,48 @@
+// scalac: -Werror
+def logLevelDetail(level: Int): String =
+   s"""$level
+
+// the following line is indented using [tab][tab]
+		Sets the global logging level to $level.
+    """
+ /* was 2 errors with carets as shown
+  |                                               ^    ^
+  |                                               Incompatible combinations of tabs and spaces in indentation prefixes.
+  |                                               Previous indent : 3 spaces
+  |                                               Latest indent   : 2 tabs
+  */
+
+def log(level: Int, msg: String): String =
+  s"""
+		$level
+  prefixed $level suffixed
+  """
+/*
+            ^    ^
+            Incompatible combinations of tabs and spaces in indentation prefixes.
+            Previous indent : 2 tabs
+            Latest indent   : 2 space
+ */
+
+// normal mixed tabs errors as a baseline
+def g =
+    42
+	+ 17   // error
+
+def p() =
+    println("hello")
+	println("world")  // error
+  /*
+   |    Incompatible combinations of tabs and spaces in indentation prefixes.
+   |    Previous indent : 4 spaces
+   |    Latest indent   : 1 tab
+   */
+
+def braced() =
+  s"""begin
+  ${
+      val level = 10
+    val msg = "hello, world"  // error he lets me off with a warning
+    log(level, msg)           // error
+   }
+   end"""

Original file line number	Diff line number	Diff line change
`@@ -351,7 +351,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {`
`351`	`351`	`}`
`352`	`352`	`else parents`
`353`	`353`	`val cls = newNormalizedClassSymbol(owner, tpnme.ANON_CLASS, Synthetic \| Final, parents1,`
`354`		`- newScope, coord = fns.map(_.span).reduceLeft(_ union _))`
	`354`	`+ coord = fns.map(_.span).reduceLeft(_ union _))`
`355`	`355`	`val constr = newConstructor(cls, Synthetic, Nil, Nil).entered`
`356`	`356`	`def forwarder(fn: TermSymbol, name: TermName) = {`
`357`	`357`	`val fwdMeth = fn.copy(cls, name, Synthetic \| Method \| Final).entered.asTerm`