.

Author: lihaoyi

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

@@ -1353,33 +1353,73 @@ object Parsers {
      *  The amount of whitespace to remove is determined by the indentation
      *  of the last line (which should contain only whitespace before the
      *  closing delimiter).
+     *
+     *  @param str The string content to dedent
+     *  @param offset The source offset where the string literal begins
+     *  @return The dedented string, or str if errors were reported
      */
-    private def dedentString(str: String): String = {
+    private def dedentString(str: String, offset: Offset): String = {
       if (str.isEmpty) return str
 
       // Find the last line (should be just whitespace before closing delimiter)
       val lastNewlineIdx = str.lastIndexOf('\n')
-      assert(
-        lastNewlineIdx >= 0,
-        "Dedented string literal must contain at least two newlines"
-      )
+      if (lastNewlineIdx < 0) {
+        syntaxError(
+          em"dedented string literal must start with newline after opening quotes",
+          offset
+        )
+        return str
+      }
 
       val closingIndent = str.substring(lastNewlineIdx + 1)
-      assert(
-        closingIndent.forall(_.isWhitespace),
-        "Last line of a dedented string literal must contain only whitespace followed by the closing delimiter"
-      )
+      if (!closingIndent.forall(_.isWhitespace)) {
+        syntaxError(
+          em"last line of dedented string literal must contain only whitespace before closing delimiter",
+          offset
+        )
+        return str
+      }
+
+      // 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 lines = str.linesIterator.toSeq
 
       // Process all lines except the last (which is just the closing indentation)
+      var lineOffset = offset
       val dedented = lines.dropRight(1).map { line =>
-        if (line.startsWith(closingIndent)) line.substring(closingIndent.length)
-        else if (line.trim.isEmpty) "" // Empty or whitespace-only lines
-        else assert(
-          false,
-          s"line \"$line\" in dedented string must be either empty or be further indented than the closing delimiter"
-        )
+        val result =
+          if (line.startsWith(closingIndent)) line.substring(closingIndent.length)
+          else if (line.trim.isEmpty) "" // Empty or whitespace-only lines
+          else {
+            // 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 += line.length + 1  // +1 for the newline
+        result
       }
 
       // Drop the first line if it's empty (the newline after opening delimiter)
@@ -1424,7 +1464,7 @@ object Parsers {
               // For non-interpolated dedented strings, check if the token starts with '''
               val str = in.strVal
               if (token == STRINGLIT && !inStringInterpolation && isDedentedStringLiteral(negOffset)) {
-                dedentString(str)
+                dedentString(str, negOffset)
               } else str
             case TRUE                          => true
             case FALSE                         => false

tests/neg/dedented-string-literals.check

@@ -10,16 +10,16 @@
 13 |  val mixedTabsSpaces = '''
    |                        ^
    |dedented string literal cannot mix tabs and spaces in indentation
--- [E040] Syntax Error: tests/neg/dedented-string-literals.scala:19:17
-19 |  val unclosed = '''
-   |                 ^
-   |unclosed dedented string literal
--- [E040] Syntax Error: tests/neg/dedented-string-literals.scala:23:35
-23 |  val nonWhitespaceBeforeClosing = '''
+-- Error: tests/neg/dedented-string-literals.scala:19:35
+19 |  val nonWhitespaceBeforeClosing = '''
    |                                   ^
-   |unclosed dedented string literal
--- Error: tests/neg/dedented-string-literals.scala:39:4
-39 |    onlyAtCompileTime // error
+   |last line of dedented string literal must contain only whitespace before closing delimiter
+-- Error: tests/neg/dedented-string-literals.scala:35:4
+35 |    onlyAtCompileTime // error
    |    ^^^^^^^^^^^^^^^^^
    |This method should only be used at compile time
    |Do not call at runtime
+-- [E040] Syntax Error: tests/neg/dedented-string-literals.scala:41:17
+41 |  val unclosed = '''
+   |                 ^
+   |unclosed dedented string literal

tests/neg/dedented-string-literals.scala

@@ -1,28 +1,24 @@
 // Test error cases for dedented string literals
 
-object DedentedStringErrors { // nopos-error // nopos-error // nopos-error
+object DedentedStringErrors {
   // Error: No newline after opening quotes
-  val noNewlineAfterOpen = '''content on same line // error
+  val noNewlineAfterOpen = '''content on same line // error: dedented string literal must start with a newline
 
   // Error: Content not indented enough
   val notIndented = '''
-content
+content // error: line in dedented string literal is indented less than the closing delimiter
   '''
 
-  // Error: Mixed tabs and spaces
+  // Error: Mixed tabs and spaces - first line has tab, but closing delimiter has spaces
   val mixedTabsSpaces = '''
-	tab line
+	tab line // error: line in dedented string literal is indented less than the closing delimiter
   space line
 	'''
 
-  // Error: Unclosed literal
-  val unclosed = '''
-some content
-
   // Error: Non-whitespace before closing delimiter
   val nonWhitespaceBeforeClosing = '''
   content here
-  text'''
+  text''' // error: last line of dedented string literal must contain only whitespace before closing delimiter
 }
 
 // Test @compileTimeOnly with dedented string
@@ -39,3 +35,8 @@ object CompileTimeOnlyTest {
     onlyAtCompileTime // error
   }
 }
+
+// Error: Unclosed literal - must be last since it breaks parsing
+object UnclosedTest {
+  val unclosed = ''' // error: unclosed dedented string literal
+some content