Merge pull request #7185 from dotty-staging/change-indent-colon

Don't require colon after class or object signatures

Author: odersky

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

@@ -7,7 +7,7 @@ package jvm
  * the compiler cake (Global).
  */
 final class BCodeAsmCommon[I <: BackendInterface](val interface: I) {
-import interface._
+  import interface._
 
   /**
    * True if `classSym` is an anonymous class or a local class. I.e., false if `classSym` is a

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

@@ -1178,6 +1178,11 @@ object Parsers {
       newLineOptWhenFollowedBy(LBRACE)
     }
 
+    def possibleTemplateStart(): Unit = {
+      in.observeIndented()
+      newLineOptWhenFollowedBy(LBRACE)
+    }
+
     def indentRegion[T](tag: EndMarkerTag)(op: => T): T = {
       val iw = in.currentRegion.indentWidth
       val t = op
@@ -3330,7 +3335,7 @@ object Parsers {
           if (in.token == LPAREN)
             try paramClause(prefix = true) :: Nil
             finally {
-              possibleBracesStart()
+              possibleTemplateStart()
               if (!in.isNestedStart) syntaxErrorOrIncomplete("`{' expected")
             }
           else Nil
@@ -3348,7 +3353,7 @@ object Parsers {
             DefDef(name, tparams, vparamss, parents.head, expr())
           }
           else {
-            possibleBracesStart()
+            possibleTemplateStart()
             val (tparams1, vparamss1) =
               if (leadingParamss.nonEmpty)
                 (tparams, leadingParamss)
@@ -3448,7 +3453,7 @@ object Parsers {
      */
     def template(constr: DefDef, isEnum: Boolean = false): Template = {
       val (parents, derived) = inheritClauses()
-      possibleBracesStart()
+      possibleTemplateStart()
       if (isEnum) {
         val (self, stats) = withinEnum(templateBody())
         Template(constr, parents, derived, self, stats)
@@ -3458,13 +3463,15 @@ object Parsers {
 
     /** TemplateOpt = [Template]
      */
-    def templateOpt(constr: DefDef): Template = {
+    def templateOpt(constr: DefDef): Template =
       possibleBracesStart()
-      if (in.token == EXTENDS || isIdent(nme.derives) || in.isNestedStart)
+      if (in.token == EXTENDS || isIdent(nme.derives))
         template(constr)
-      else
-        Template(constr, Nil, Nil, EmptyValDef, Nil)
-    }
+      else {
+        possibleTemplateStart()
+        if (in.isNestedStart) template(constr)
+        else Template(constr, Nil, Nil, EmptyValDef, Nil)
+      }
 
     /** TemplateBody ::= [nl] `{' TemplateStatSeq `}'
      */
@@ -3496,7 +3503,7 @@ object Parsers {
     def packaging(start: Int): Tree = {
       val pkg = qualId()
       indentRegion(pkg) {
-        possibleBracesStart()
+        possibleTemplateStart()
         val stats = inDefScopeBraces(topStatSeq())
         makePackaging(start, pkg, stats)
       }
@@ -3702,7 +3709,7 @@ object Parsers {
           else {
             val pkg = qualId()
             indentRegion(pkg) {
-              possibleBracesStart()
+              possibleTemplateStart()
               if (in.token == EOF)
                 ts += makePackaging(start, pkg, List())
               else if (in.isNestedStart) {

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

@@ -28,6 +28,8 @@ object Scanners {
 
   type Token = Int
 
+  private val identity: IndentWidth => IndentWidth = Predef.identity
+
   trait TokenData {
 
     /** the next token */
@@ -372,7 +374,7 @@ object Scanners {
     def isLeadingInfixOperator() = (
           allowLeadingInfixOperators
       && (  token == BACKQUOTED_IDENT
-          || token == IDENTIFIER && isOperatorPart(name(name.length - 1)))
+         || token == IDENTIFIER && isOperatorPart(name(name.length - 1)))
       && ch == ' '
       && !pastBlankLine
       && {
@@ -392,25 +394,24 @@ object Scanners {
       }
     )
 
-    /** The indentation width of the given offset.
-     *  It is assumed that only blank characters are between the start of the line and the offset.
-     */
+    /** The indentation width of the given offset */
     def indentWidth(offset: Offset): IndentWidth = {
       import IndentWidth.{Run, Conc}
-      def recur(idx: Int, ch: Char, n: Int): IndentWidth =
-        if (idx < 0) Run(ch, n)
+      def recur(idx: Int, ch: Char, n: Int, k: IndentWidth => IndentWidth): IndentWidth =
+        if (idx < 0) k(Run(ch, n))
         else {
           val nextChar = buf(idx)
-          if (nextChar == ' ' || nextChar == '\t')
+          if (nextChar == LF) k(Run(ch, n))
+          else if (nextChar == ' ' || nextChar == '\t')
             if (nextChar == ch)
-              recur(idx - 1, ch, n + 1)
+              recur(idx - 1, ch, n + 1, k)
             else {
-              val prefix = recur(idx - 1, nextChar, 1)
-              if (n == 0) prefix else Conc(prefix, Run(ch, n))
+              val k1: IndentWidth => IndentWidth = if (n == 0) k else Conc(_, Run(ch, n))
+              recur(idx - 1, nextChar, 1, k1)
             }
-          else Run(ch, n)
+          else recur(idx - 1, ' ', 0, identity)
         }
-      recur(offset - 1, ' ', 0)
+      recur(offset - 1, ' ', 0, identity)
     }
 
     /** Handle newlines, possibly inserting an INDENT, OUTDENT, NEWLINE, or NEWLINES token
@@ -531,6 +532,25 @@ object Scanners {
       }
     }
 
+    def observeIndented(): Unit =
+      if (indentSyntax && isAfterLineEnd && token != INDENT) {
+        val newLineInserted = token == NEWLINE || token == NEWLINES
+        val nextOffset = if (newLineInserted) next.offset else offset
+        val nextWidth = indentWidth(nextOffset)
+        val lastWidth = currentRegion match {
+          case r: Indented => r.width
+          case r: InBraces => r.width
+          case _ => nextWidth
+        }
+
+        if (lastWidth < nextWidth) {
+          currentRegion = Indented(nextWidth, Set(), COLONEOL, currentRegion)
+          if (!newLineInserted) next.copyFrom(this)
+          offset = nextOffset
+          token = INDENT
+        }
+      }
+
     /** - Join CASE + CLASS => CASECLASS, CASE + OBJECT => CASEOBJECT, SEMI + ELSE => ELSE, COLON + <EOL> => COLONEOL
      *  - Insert missing OUTDENTs at EOF
      */
@@ -1267,6 +1287,7 @@ object Scanners {
    /* Initialization: read first char, then first token */
     nextChar()
     nextToken()
+    currentRegion = Indented(indentWidth(offset), Set(), EMPTY, null)
   }
   // end Scanner
 
@@ -1342,6 +1363,7 @@ object Scanners {
       }
     }
   }
+
   object IndentWidth {
     private inline val MaxCached = 40
     private val spaces = Array.tabulate(MaxCached + 1)(new Run(' ', _))

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

@@ -34,7 +34,7 @@ class DocumentSymbolTest {
 
   @Test def documentSymbolShowClassAndCompanion: Unit = {
     code"""object ${m1}Foo${m2}
-           class ${m3}Foo${m4}""".withSource
+          |class ${m3}Foo${m4}""".withSource
       .documentSymbol(m1, (m1 to m2).symInfo("Foo", SymbolKind.Module),
                           (m3 to m4).symInfo("Foo", SymbolKind.Class))
   }

language-server/test/dotty/tools/languageserver/DocumentSymbolTest.scala

@@ -37,7 +37,7 @@ class ReferencesTest {
 
   @Test def classReferenceCompanion: Unit = {
     code"""class ${m1}Foo${m2}(x: Any)
-           object ${m3}Foo${m4} { val bar = new ${m5}Foo${m6}(${m7}Foo${m8}) }""".withSource
+          |object ${m3}Foo${m4} { val bar = new ${m5}Foo${m6}(${m7}Foo${m8}) }""".withSource
       .references(m1 to m2, List(m1 to m2, m5 to m6), withDecl = true)
       .references(m1 to m2, List(m5 to m6), withDecl = false)
       .references(m3 to m4, List(m3 to m4, m7 to m8), withDecl = true)
@@ -50,9 +50,9 @@ class ReferencesTest {
 
   @Test def anonClassTrait: Unit = {
     code"""trait ${m1}Foo${m2}
-           object O {
-             val foo = new ${m3}Foo${m4} {}
-           }""".withSource
+          |object O {
+          |  val foo = new ${m3}Foo${m4} {}
+          |}""".withSource
       .references(m1 to m2, List(m1 to m2, m3 to m4), withDecl = true)
       .references(m1 to m2, List(m3 to m4), withDecl = false)
       .references(m3 to m4, List(m1 to m2, m3 to m4), withDecl = true)
@@ -170,12 +170,12 @@ class ReferencesTest {
 
     val p1 = Project.dependingOn(p0).withSources(
       code"""class B {
-               val a = new A()
-               val z = new a.Z()
-               val y = new z.Y()
-               val x = new y.X()
-               x.${m3}x${m4}
-             }"""
+            |  val a = new A()
+            |  val z = new a.Z()
+            |  val y = new z.Y()
+            |  val x = new y.X()
+            |  x.${m3}x${m4}
+            |}"""
     )
 
     withProjects(p0, p1)
@@ -204,12 +204,12 @@ class ReferencesTest {
   @Test def findReferencesInUntouchedProject: Unit = {
     val p0 = Project.withSources(
       code"""package hello
-             object A { def ${m1}foo${m2} = 1 }"""
+            |object A { def ${m1}foo${m2} = 1 }"""
     )
 
     val p1 = Project.dependingOn(p0).withSources(
       tasty"""package hello
-              object B { def bar = A.${m3}foo${m4} }"""
+            |object B { def bar = A.${m3}foo${m4} }"""
     )
 
     withProjects(p0, p1)
@@ -219,8 +219,8 @@ class ReferencesTest {
 
   @Test def importReference1: Unit = {
     code"""import ${m1}Foo${m2}._
-           object ${m3}Foo${m4} { def ${m5}bar${m6}: Int = 0 }
-           trait Bar { def buzz = ${m7}bar${m8} }""".withSource
+          |object ${m3}Foo${m4} { def ${m5}bar${m6}: Int = 0 }
+          |trait Bar { def buzz = ${m7}bar${m8} }""".withSource
 
       .references(m1 to m2, List(m1 to m2, m3 to m4), withDecl = true)
       .references(m1 to m2, List(m1 to m2), withDecl = false)
@@ -266,7 +266,7 @@ class ReferencesTest {
 
   @Test def importReferenceClassAndCompanion: Unit = {
     code"""object Foo { object ${m1}Bar${m2}; class ${m3}Bar${m4} }
-           trait Buzz { import Foo.${m5}Bar${m6} }""".withSource
+          |trait Buzz { import Foo.${m5}Bar${m6} }""".withSource
       .references(m1 to m2, List(m1 to m2, m5 to m6), withDecl = true)
       .references(m1 to m2, List(m5 to m6), withDecl = false)
       .references(m3 to m4, List(m3 to m4, m5 to m6), withDecl = true)
@@ -277,7 +277,7 @@ class ReferencesTest {
 
   @Test def importReferenceWithRename: Unit = {
     code"""object ${m1}Foo${m2} { object ${m3}Bar${m4} { object ${m5}Baz${m6} } }
-           trait Buzz { import ${m7}Foo${m8}.${m9}Bar${m10}.{${m11}Baz${m12} => ${m13}Quux${m14}}""".withSource
+          |trait Buzz { import ${m7}Foo${m8}.${m9}Bar${m10}.{${m11}Baz${m12} => ${m13}Quux${m14}}""".withSource
 
     .references(m1 to m2, List(m1 to m2, m7 to m8), withDecl = true)
     .references(m1 to m2, List(m7 to m8), withDecl = false)
@@ -297,7 +297,7 @@ class ReferencesTest {
 
   @Test def importReferenceClassAndCompanionWithRename: Unit = {
     code"""object ${m1}Foo${m2} { object ${m3}Bar${m4}; class ${m5}Bar${m6} }
-           trait Buzz { import ${m7}Foo${m8}.{${m9}Bar${m10} => ${m11}Baz${m12}} }""".withSource
+          |trait Buzz { import ${m7}Foo${m8}.{${m9}Bar${m10} => ${m11}Baz${m12}} }""".withSource
 
       .references(m1 to m2, List(m1 to m2, m7 to m8), withDecl = true)
       .references(m1 to m2, List(m7 to m8), withDecl = false)
@@ -315,7 +315,7 @@ class ReferencesTest {
 
   @Test def importReferenceMembers: Unit = {
     code"""object Foo { def ${m1}bar${m2} = 2; type ${m3}bar${m4} = fizz; class fizz }
-           trait Quux { import Foo.{${m5}bar${m6} => ${m7}buzz${m8}} }""".withSource
+          |trait Quux { import Foo.{${m5}bar${m6} => ${m7}buzz${m8}} }""".withSource
 
     .references(m1 to m2, List(m1 to m2, m5 to m6, m7 to m8), withDecl = true)
     .references(m1 to m2, List(m5 to m6, m7 to m8), withDecl = false)
@@ -331,7 +331,7 @@ class ReferencesTest {
     withSources(
       code"""object A { class ${m1}B${m2}; class ${m3}C${m4} }""",
       code"""import A.{${m5}B${m6} => ${m7}B2${m8}, ${m9}C${m10} => ${m11}C2${m12}}
-             class E"""
+            |class E"""
     ).references(m1 to m2, List(m1 to m2, m5 to m6, m7 to m8), withDecl = true)
      .references(m1 to m2, List(m5 to m6, m7 to m8), withDecl = false)
      .references(m3 to m4, List(m3 to m4, m9 to m10, m11 to m12), withDecl = true)

language-server/test/dotty/tools/languageserver/ReferencesTest.scala

@@ -35,7 +35,7 @@ class SymbolTest {
 
   @Test def symbolShowClassAndCompanion: Unit = {
     code"""object ${m1}Foo${m2}
-           class ${m3}Foo${m4}""".withSource
+          |class ${m3}Foo${m4}""".withSource
       .symbol("Foo", (m1 to m2).symInfo("Foo", SymbolKind.Module),
                      (m3 to m4).symInfo("Foo", SymbolKind.Class))
   }

language-server/test/dotty/tools/languageserver/SymbolTest.scala

@@ -42,7 +42,7 @@ class WorksheetTest {
 
   @Test def defineCaseClass: Unit = {
     ws"""${m1}case class Foo(x: Int)${m2}
-         ${m3}Foo(1)${m4}""".withSource
+        |${m3}Foo(1)${m4}""".withSource
       .run(m1,
         ((m1 to m2), "// defined case class Foo"),
         ((m3 to m4), "val res0: Foo = Foo(1)"))
@@ -68,10 +68,10 @@ class WorksheetTest {
 
   @Test def defineAnonymousClass1: Unit = {
     ws"""${m1}class Foo${m2}
-         ${m3}trait Bar${m4}
-         ${m5}new Foo with Bar {
-           override def toString: String = "Foo"
-         }${m6}""".withSource
+        |${m3}trait Bar${m4}
+        |${m5}new Foo with Bar {
+        |   override def toString: String = "Foo"
+        |}${m6}""".withSource
       .run(m1,
         ((m1 to m2), "// defined class Foo"),
         ((m3 to m4), "// defined trait Bar"),

language-server/test/dotty/tools/languageserver/WorksheetTest.scala

@@ -1,4 +1,4 @@
-object Test:
+object Test
 
   locally:
     var x = 0
@@ -52,28 +52,28 @@ object Test:
     x < 10
   do ()
 
-class Test2:
+class Test2
   self =>
   def foo = 1
 
-  object x:
+  object x
     new Test2:
       override def foo = 2
       end new               // error: end of statement expected but new found  // error: not found: end
     def bar = 2             // error: ';' expected, but unindent found
   end Test2                 // error: misaligned end marker
 end Test2
 
-class Test3:
+class Test3
  self =>
   def foo = 1
  end Test3  // error: not found: end
 
 import collection.mutable.HashMap
 
-class Coder(words: List[String]):
+class Coder(words: List[String])
 
-  class Foo:
+  class Foo
     println()
     end Foo  // error: not found: end