Allow lines starting with a dot to fall outside previous indentation widths

If line following some indented code starts with a '`.`' and its indentation width is different from the
indentation widths of the two neighboring regions by more than a single space, the line accepted even
if it does not match a previous indentation width.

Author: odersky

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3080,8 +3080,8 @@ object Parsers {
  /* -------- PARAMETERS ------------------------------------------- */
 
     /** DefParamClauses       ::= DefParamClause { DefParamClause }  -- and two DefTypeParamClause cannot be adjacent
-     *  DefParamClause        ::= DefTypeParamClause 
-     *                          | DefTermParamClause 
+     *  DefParamClause        ::= DefTypeParamClause
+     *                          | DefTermParamClause
      *                          | UsingParamClause
      */
     def typeOrTermParamClauses(
@@ -3179,7 +3179,7 @@ object Parsers {
      *  UsingClsTermParamClause::= ‘(’ ‘using’ [‘erased’] (ClsParams | ContextTypes) ‘)’
      *  ClsParams         ::=  ClsParam {‘,’ ClsParam}
      *  ClsParam          ::=  {Annotation}
-     * 
+     *
      *  TypelessClause    ::= DefTermParamClause
      *                      | UsingParamClause
      *
@@ -3557,13 +3557,12 @@ object Parsers {
       }
     }
 
-    
 
     /** DefDef  ::=  DefSig [‘:’ Type] ‘=’ Expr
      *            |  this TypelessClauses [DefImplicitClause] `=' ConstrExpr
      *  DefDcl  ::=  DefSig `:' Type
      *  DefSig  ::=  id [DefTypeParamClause] DefTermParamClauses
-     * 
+     *
      * if clauseInterleaving is enabled:
      *  DefSig  ::=  id [DefParamClauses] [DefImplicitClause]
      */
@@ -3602,8 +3601,8 @@ object Parsers {
         val mods1 = addFlag(mods, Method)
         val ident = termIdent()
         var name = ident.name.asTermName
-        val paramss = 
-          if in.featureEnabled(Feature.clauseInterleaving) then 
+        val paramss =
+          if in.featureEnabled(Feature.clauseInterleaving) then
             // If you are making interleaving stable manually, please refer to the PR introducing it instead, section "How to make non-experimental"
             typeOrTermParamClauses(ParamOwner.Def, numLeadParams = numLeadParams)
           else
@@ -3613,7 +3612,7 @@ object Parsers {
             joinParams(tparams, vparamss)
 
         var tpt = fromWithinReturnType { typedOpt() }
-        
+
         if (migrateTo3) newLineOptWhenFollowedBy(LBRACE)
         val rhs =
           if in.token == EQUALS then

compiler/src/dotty/tools/dotc/parsing/Scanners.scala

@@ -610,11 +610,17 @@ object Scanners {
               case r: Indented =>
                 insert(OUTDENT, offset)
                 handleNewIndentWidth(r.enclosing, ir =>
-                  val lw = lastWidth
-                  errorButContinue(
-                    em"""The start of this line does not match any of the previous indentation widths.
-                        |Indentation width of current line : $nextWidth
-                        |This falls between previous widths: ${ir.width} and $lw"""))
+                  if next.token == DOT
+                      && !nextWidth.isClose(r.indentWidth)
+                      && !nextWidth.isClose(ir.indentWidth)
+                  then
+                    ir.otherIndentWidths += nextWidth
+                  else
+                    val lw = lastWidth
+                    errorButContinue(
+                      em"""The start of this line does not match any of the previous indentation widths.
+                          |Indentation width of current line : $nextWidth
+                          |This falls between previous widths: ${ir.width} and $lw"""))
               case r =>
                 if skipping then
                   if r.enclosing.isClosedByUndentAt(nextWidth) then
@@ -1665,6 +1671,17 @@ object Scanners {
 
     def < (that: IndentWidth): Boolean = this <= that && !(that <= this)
 
+    /** Does `this` differ from `that` by not more than a single space? */
+    def isClose(that: IndentWidth): Boolean = this match
+      case Run(ch1, n1) =>
+        that match
+          case Run(ch2, n2) => ch1 == ch2 && ch1 != '\t' && (n1 - n2).abs <= 1
+          case Conc(l, r) => false
+      case Conc(l1, r1) =>
+        that match
+          case Conc(l2, r2) => l1 == l2 && r1.isClose(r2)
+          case _ => false
+
     def toPrefix: String = this match {
       case Run(ch, n) => ch.toString * n
       case Conc(l, r) => l.toPrefix ++ r.toPrefix

docs/_docs/reference/other-new-features/indentation.md

@@ -100,7 +100,7 @@ There are two rules:
 
      - An `<outdent>` is finally inserted in front of a comma that follows a statement sequence starting with an `<indent>` if the indented region is itself enclosed in parentheses.
 
-It is an error if the indentation width of the token following an `<outdent>` does not match the indentation of some previous line in the enclosing indentation region. For instance, the following would be rejected.
+It is generally an error if the indentation width of the token following an `<outdent>` does not match the indentation of some previous line in the enclosing indentation region. For instance, the following would be rejected.
 
 ```scala
 if x < 0 then
@@ -109,6 +109,19 @@ if x < 0 then
     x
 ```
 
+However, there is one exception to this rule: If the next line starts with a '`.`' _and_ the indentation
+width is different from the indentation widths of the two neighboring regions by more than a single space, the line accepted. For instance, the following is OK:
+
+```scala
+xs.map: x =>
+    x + 1
+  .filter: x =>
+    x > 0
+```
+Here, the line starting with `.filter` does not have an indentation level matching a previous line,
+but it is still accepted since it starts with a '`.`' and differs in at least two spaces from the
+indentation levels of both the region that is closed and the next outer region.
+
 Indentation tokens are only inserted in regions where newline statement separators are also inferred:
 at the top-level, inside braces `{...}`, but not inside parentheses `(...)`, patterns or types.
 

tests/neg/outdent-dot.check

@@ -0,0 +1,18 @@
+-- Error: tests/neg/outdent-dot.scala:6:5 ------------------------------------------------------------------------------
+6 |     .toString  // error
+  |     ^
+  |     The start of this line does not match any of the previous indentation widths.
+  |     Indentation width of current line : 5 spaces
+  |     This falls between previous widths: 2 spaces and 6 spaces
+-- Error: tests/neg/outdent-dot.scala:11:3 -----------------------------------------------------------------------------
+11 |   .filter: x =>  // error
+   |   ^
+   |   The start of this line does not match any of the previous indentation widths.
+   |   Indentation width of current line : 3 spaces
+   |   This falls between previous widths: 2 spaces and 6 spaces
+-- Error: tests/neg/outdent-dot.scala:13:4 -----------------------------------------------------------------------------
+13 |    println("foo")  // error
+   |    ^
+   |    The start of this line does not match any of the previous indentation widths.
+   |    Indentation width of current line : 4 spaces
+   |    This falls between previous widths: 2 spaces and 6 spaces

tests/neg/outdent-dot.scala

@@ -0,0 +1,13 @@
+def Block(f: => Int): Int = f
+
+def bar(): String =
+  Block:
+      2 + 2
+     .toString  // error
+
+def foo(xs: List[Int]) =
+  xs.map: x =>
+      x + 1
+   .filter: x =>  // error
+      x > 0
+    println("foo")  // error

tests/pos/outdent-dot.scala

@@ -0,0 +1,13 @@
+def Block(f: => Int): Int = f
+
+def bar(): String =
+  Block:
+      2 + 2
+    .toString
+
+def foo(xs: List[Int]) =
+  xs.map: x =>
+      x + 1
+    .filter: x =>
+      x > 0
+    println("foo")