first iteration of offset tracking

Author: cottand

src/main/java/org/nixos/idea/psi/NixStringLiteralEscaper.kt

@@ -4,30 +4,131 @@ import com.intellij.openapi.util.TextRange
 import com.intellij.psi.LiteralTextEscaper
 import com.intellij.psi.PsiLanguageInjectionHost
 import org.nixos.idea.psi.impl.AbstractNixString
-import org.nixos.idea.util.NixIndStringUtil
-import org.nixos.idea.util.NixStringUtil
 
 class NixStringLiteralEscaper(host: AbstractNixString) : LiteralTextEscaper<PsiLanguageInjectionHost>(host) {
 
     override fun isOneLine(): Boolean = false
 
+    private var outSourceOffsets: IntArray? = null
+
+    override fun getRelevantTextRange(): TextRange {
+        if (myHost.textLength <= 4) return TextRange.EMPTY_RANGE
+        return TextRange.create(2, myHost.textLength - 2)
+    }
+
     override fun decode(rangeInsideHost: TextRange, outChars: StringBuilder): Boolean {
+        // only indented strings supported for now
+        if (myHost !is NixIndString) return false
+
         val subText: String = rangeInsideHost.substring(myHost.text)
-        if (myHost is NixIndString) {
-            outChars.append(NixIndStringUtil.escape(subText))
-        } else {
-            NixStringUtil.escape(outChars, subText)
-        }
-        return true
+
+
+        val array = IntArray(subText.length + 1)
+        val success = unescapeAndDecode(subText, outChars, array, interpolations = false)
+        outSourceOffsets = array
+        return success
     }
 
     override fun getOffsetInHost(offsetInDecoded: Int, rangeInsideHost: TextRange): Int {
-        // TODO: Implement proper String back-feed support.
-        //  this involves keeping track of text offsets between decoded
-        //  and encoded Nix text. See how Terraform does it here:
-        //  https://github.com/JetBrains/intellij-plugins/blob/master/terraform/src/org/intellij/terraform/hcl/psi/impl/HCLStringLiteralTextEscaper.kt
-        val offsetInHost = offsetInDecoded + rangeInsideHost.startOffset
-        return (offsetInHost).coerceIn(rangeInsideHost.startOffset..rangeInsideHost.endOffset)
+        val offsets = outSourceOffsets ?: throw IllegalStateException("#decode was not called")
+        val result = if (offsetInDecoded < offsets.size) offsets[offsetInDecoded] else -1
+        println("gotOffsetInHost decoded=${offsetInDecoded} rangeInsideHost=${rangeInsideHost} result=$result")
+        return result.coerceIn(2..rangeInsideHost.length) + rangeInsideHost.startOffset
+    }
+
+    companion object {
+        fun unescapeAndDecode(
+            chars: String,
+            outChars: StringBuilder,
+            sourceOffsets: IntArray?,
+            interpolations: Boolean
+        ): Boolean {
+            assert(sourceOffsets == null || sourceOffsets.size == chars.length + 1)
+
+            var index = 0
+            val outOffset = outChars.length
+            var braces = 0
+
+
+            while (index < chars.length) {
+                fun updateOffsets(index: Int) {
+                    if (sourceOffsets != null) {
+                        sourceOffsets[outChars.length - outOffset] = index - 1
+                        sourceOffsets[outChars.length - outOffset + 1] = index
+                    }
+                }
+                var c = chars[index++]
+
+                updateOffsets(index)
+
+
+                if (braces > 0) {
+                    if (c == '{') braces++
+                    else if (c == '}') braces--
+                    outChars.append(c)
+                    continue
+                }
+
+                if (c == '\'') {
+                    if (index == chars.length) return false
+                    c = chars[index++]
+
+                    if (c != '\'') {
+                        // if what follows isn't another ' then we are not escaping anything,
+                        // so we can continue
+                        outChars.append("\'")
+                        updateOffsets(index - 1)
+                        outChars.append(c)
+                        continue
+                    }
+
+                    if (index == chars.length) return false
+                    c = chars[index++]
+
+                    when(c) {
+                        // '' can be escaped by prefixing it with ', i.e., '''.
+                        '\'' -> {
+                            outChars.append("\'")
+                            updateOffsets(index - 1)
+                            outChars.append(c)
+                        }
+                        //  $ can be escaped by prefixing it with '' (that is, two single quotes), i.e., ''$.
+                        '$' -> outChars.append(c)
+                        // Linefeed, carriage-return and tab characters can
+                        // be written as ''\n, ''\r, ''\t, and ''\ escapes any other character.
+                        'a' -> outChars.append(0x07.toChar())
+                        'b' -> outChars.append('\b')
+                        'f' -> outChars.append(0x0c.toChar())
+                        'n' -> outChars.append('\n')
+                        't' -> outChars.append('\t')
+                        'r' -> outChars.append('\r')
+                        'v' -> outChars.append(0x0b.toChar())
+                        else -> return false
+                    }
+                }
+
+//                 // $ removes any special meaning from the following $.
+//                if (c == '$') {
+//                    if (index == chars.length) return false
+//                    c = chars[index++]
+//                    if (c != '$') {
+//                        // if what follows isn't another ' then we are not escaping anything,
+//                        // so we can continue
+//                        outChars.append('$')
+//                        updateOffsets(index - 1)
+//                        outChars.append(c)
+//                        continue
+//                    }
+//                    // what here??
+//                }
+
+
+                if (sourceOffsets != null) {
+                    sourceOffsets[outChars.length - outOffset] = index
+                }
+            }
+            return true
+        }
     }
 
 }

src/main/java/org/nixos/idea/util/NixIndStringUtil.kt

@@ -2,7 +2,7 @@ package org.nixos.idea.util
 
 object NixIndStringUtil {
     /**
-     * Escapes the given string for use in a double-quoted string expression in the Nix Expression Language.
+     * Unescapes the given string for use in a double-quoted string expression in the Nix Expression Language.
      *
      * See [Nix docs](https://nix.dev/manual/nix/2.22/language/values.html#type-string) for the logic, which
      * is non-trivial.
@@ -21,7 +21,7 @@ object NixIndStringUtil {
      * ```
      */
     @JvmStatic
-    fun escape(chars: CharSequence): String = buildString {
+    fun unescape(chars: CharSequence): String = buildString {
         for ((index, c) in chars.withIndex()) {
             fun prevChar() = chars.getOrNull(index - 1)
             fun prev2Chars(): String? {

src/test/java/org/nixos/idea/util/NixIndStringUtilTest.java

@@ -26,8 +26,8 @@ final class NixIndStringUtilTest {
             # which needs a surrogate pair to be represented in UTF-16
             \uD83C\uDF09    , \uD83C\uDF09
             """)
-    void escape(String unescaped, String expectedResult) {
-        var str = NixIndStringUtil.escape(unescaped);
+    void unescape(String unescaped, String expectedResult) {
+        var str = NixIndStringUtil.unescape(unescaped);
         assertEquals(expectedResult, str);
     }
 }