Revert "cleanup"

This reverts commit 3aefb59.

Author: lihaoyi

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

@@ -1368,26 +1368,43 @@ object Parsers {
       // APIs behaves predictably in the presence of empty leading/trailing lines
       if (closingIndent == "") str
       else {
-        if (closingIndent.contains('\t') && closingIndent.contains(' ')) {
+        // Check for mixed tabs and spaces in closing indent
+
+        val hasTabs = closingIndent.contains('\t')
+        val hasSpaces = closingIndent.contains(' ')
+        if (hasTabs && hasSpaces) {
           syntaxError(
             em"dedented string literal cannot mix tabs and spaces in indentation",
             offset
           )
           return str
         }
 
+        // Split into lines
         val linesAndWithSeps = (str.linesIterator.zip(str.linesWithSeparators)).toSeq
+
         var lineOffset = offset
 
         def dedentLine(line: String, lineWithSep: String) = {
           val result =
             if (line.startsWith(closingIndent)) line.substring(closingIndent.length)
             else if (line.trim.isEmpty) "" // Empty or whitespace-only lines
             else {
-              syntaxError(
-                em"line in dedented string literal must be indented at least as much as the closing delimiter with an identical prefix",
-                lineOffset
-              )
+              // Check if this line has mixed tabs/spaces that don't match closing indent
+              val lineIndent = line.takeWhile(_.isWhitespace)
+              val lineHasTabs = lineIndent.contains('\t')
+              val lineHasSpaces = lineIndent.contains(' ')
+              if ((hasTabs && lineHasSpaces && !lineHasTabs) || (hasSpaces && lineHasTabs && !lineHasSpaces)) {
+                syntaxError(
+                  em"dedented string literal cannot mix tabs and spaces in indentation",
+                  offset
+                )
+              } else {
+                syntaxError(
+                  em"line in dedented string literal must be indented at least as much as the closing delimiter",
+                  lineOffset
+                )
+              }
               line
             }
           lineOffset += lineWithSep.length // Make sure to include any \n, \r, \r\n, or \n\r
@@ -1534,15 +1551,14 @@ object Parsers {
         in.charOffset + 1 < in.buf.length &&
         in.buf(in.charOffset) == '"' &&
         in.buf(in.charOffset + 1) == '"'
-
       val isDedented =
         in.charOffset + 2 < in.buf.length &&
         in.buf(in.charOffset - 1) == '\'' &&
         in.buf(in.charOffset) == '\'' &&
         in.buf(in.charOffset + 1) == '\''
-
       in.nextToken()
 
+      // Collect all string parts and their offsets
       val stringParts = new ListBuffer[(String, Offset)]
       val interpolatedExprs = new ListBuffer[Tree]
 
@@ -1553,6 +1569,7 @@ object Parsers {
         offsetCorrection = 0
         in.nextToken()
 
+        // Collect the interpolated expression
         interpolatedExprs += atSpan(in.offset) {
           if (in.token == IDENTIFIER)
             termIdent()
@@ -1574,6 +1591,7 @@ object Parsers {
         }
       }
 
+      // Get the final STRINGLIT
       val finalLiteral = if (in.token == STRINGLIT) {
         val s = in.strVal
         val off = in.offset + offsetCorrection
@@ -1593,6 +1611,7 @@ object Parsers {
           }
         }
 
+      // Build the segments with dedented strings
       for ((str, expr) <- dedentedParts.zip(interpolatedExprs)) {
         val (dedentedStr, offset) = str
         segmentBuf += Thicket(
@@ -1601,7 +1620,8 @@ object Parsers {
         )
       }
 
-      if (finalLiteral) { // Add the final literal if present
+      // Add the final literal if present
+      if (finalLiteral) {
         val (dedentedStr, offset) = dedentedParts.last
         segmentBuf += atSpan(offset, offset, offset + dedentedStr.length) { Literal(Constant(dedentedStr)) }
       }

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

@@ -990,17 +990,26 @@ object Scanners {
         case '\'' =>
           def fetchSingleQuote(): Unit = {
             nextChar()
-            if (ch == '\'') { // Check for triple single quote (dedented string literal)
+            // Check for triple single quote (dedented string literal)
+            if (ch == '\'') {
               nextChar()
               if (ch == '\'') {
-                // We have at least ''' check if this is an interpolated dedented string
+                // We have at least '''
+                // Check if this is an interpolated dedented string
                 if (token == INTERPOLATIONID) {
+                  // For interpolation, handle as string part
                   nextRawChar()
                   val quoteCount = getDedentedString(isInterpolated = true)
                   currentRegion = InDedentedString(quoteCount, currentRegion)
-                } else getDedentedString(isInterpolated = false)
+                } else {
+                  getDedentedString(isInterpolated = false)
+                  // No need to store quoteCount for non-interpolated strings
+                }
+              }
+              else {
+                // We have '' followed by something else
+                error(em"empty character literal")
               }
-              else error(em"empty character literal") // We have '' followed by something else
             }
             else if isIdentifierStart(ch) then
               charLitOr { getIdentRest(); QUOTEID }