Language.Nix.Identifier: correctly implement Nix escape sequences

This code previously assumed escape sequences in strings work like in
Haskell. This is not generally the case. This commit adds a custom
implementation of the relevant parsing and rendering logic which even
simplifies some things.

Escape sequences are a little weird in Nix since only very few things
_have_ to be escaped and some things not always, depending on
context (i.e. $). I've linked the best reference (the lexer) in the
code, but the manual is also helpful:
https://nix.dev/manual/nix/2.30/language/string-literals.html

Author: sternenseemann

language-nix/CHANGELOG.md

@@ -10,4 +10,13 @@
   `quote`, `needsQuoting` and `Pretty` will take this list into account
   and quote such identifiers. However, `HasParser` will _not_ reject them
   even if they are unquoted.
-* Add an hspec/QuickCheck based test suite.
+* Resolved discrepancies between `Language.Nix.Identifier` and Nix w.r.t.
+  quoting and escaping:
+
+  - Fixed missing escaping of some Nix syntax elements, e.g. in the case of
+   `ident # "${foo}"`.
+  - Pretty printing `Identifier`s will no longer produce escape sequences
+    Haskell supports, but Nix doesn't.
+  - Parsing `Identifier`s won't interpret escape sequences that Nix wouldn't
+    understand.
+* Added an hspec/QuickCheck based test suite.

language-nix/src/Language/Nix/Identifier.hs

@@ -87,6 +87,11 @@ instance Pretty Identifier where
 
 -- | Note that this parser is more lenient than Nix w.r.t. simple identifiers,
 --   since it will accept 'nixKeywords'.
+--
+--   Naturally, it does not support string interpolation, but does not reject
+--   strings that contain them. E.g. the string literal @"hello ${world}"@
+--   will contain @${world}@ verbatim after parsing. Do not rely on this
+--   behavior, as it may be changed in the future.
 instance HasParser Identifier where
   parser = parseQuotedIdentifier <|> parseSimpleIdentifier
 
@@ -108,17 +113,24 @@ parseQuotedIdentifier :: CharParser st tok m Identifier
 parseQuotedIdentifier = Identifier <$> qstring
   where
     qstring :: CharParser st tok m String
-    qstring = do txt <- between (P.char '"') (P.char '"') (many qtext)
-                 return (read ('"' : concat txt ++ ['"']))
+    qstring = between (P.char '"') (P.char '"') (many qtext)
 
-    qtext :: CharParser st tok m String
-    qtext = quotedPair <|> many1 (P.noneOf "\\\"")
+    qtext :: CharParser st tok m Char
+    qtext = quotedPair <|> P.noneOf "\\\""
 
-    quotedPair :: CharParser st tok m String
+    quotedPair :: CharParser st tok m Char
     quotedPair = do
-      c1 <- P.char '\\'
-      c2 <- anyChar
-      return [c1,c2]
+      _ <- P.char '\\'
+      c <- anyChar
+      -- See https://github.com/NixOS/nix/blob/2d83bc6b83763290e9bbf556209927ba469956aa/src/libexpr/lexer.l#L54-L60
+      return $ case c of
+                 'n' -> '\n'
+                 't' -> '\t'
+                 'r' -> '\r'
+                 -- Note that this handles actual escapes like \" and \\ and
+                 -- bogus cases like \f which Nix doesn't fail on (despite not
+                 -- supporting it), but simply maps to plain f
+                 _ -> c
 
 -- | Checks whether a given string needs quoting when interpreted as an
 -- 'Identifier'.
@@ -142,5 +154,28 @@ nixKeywords =
 -- abc
 -- >>> putStrLn (quote "abc.def")
 -- "abc.def"
+-- >>> putStrLn (quote "$foo")
+-- "$foo"
+-- >>> putStrLn (quote "${foo}")
+-- "\${foo}"
 quote :: String -> String
-quote s = if needsQuoting s then show s else s
+quote s = if needsQuoting s then '"' : quote' s else s
+  where
+    quote' (c1:c2:cs) = escapeChar c1 (Just c2) ++ quote' (c2:cs)
+    quote' (c:cs) = escapeChar c Nothing ++ quote' cs
+    quote' "" = "\""
+
+escapeChar :: Char -> Maybe Char -> String
+escapeChar c1 c2 =
+  case c1 of
+    -- supported escape sequences, see quotedPair above
+    -- N.B. technically, we only need to escape \r (since Nix converts raw \r to \n),
+    -- but it's nicer to escape what we can.
+    '\n' -> "\\n"
+    '\t' -> "\\t"
+    '\r' -> "\\r"
+    -- syntactically significant in doubly quoted strings
+    '\\' -> "\\\\"
+    '"' -> "\\\""
+    '$' | c2 == Just '{' -> "\\$"
+    _ -> [c1]

language-nix/test/hspec.hs

@@ -26,6 +26,18 @@ main = hspec $ do
         identProperty $ \i -> parseM "Identifier" (prettyShow i) == Just (i :: Identifier)
       it "can parse the result of quote" $
         stringIdentProperty $ \str -> parseM "Identifier" (quote str) == Just (ident # str)
+      it "parses redundant escape sequences" $
+        forM_
+          [ ("\"\\f\"", "f")
+          , ("\"echo \\$var\"", "echo $var")
+          , ("\"\\h\\e\\l\\l\\o\\ \\w\\or\\l\\d\"", "hello world")
+          -- \t and \n don't need to be escaped, though it's advisable
+          , ("\"only\\ttechnically\nredundant\"", "only\ttechnically\nredundant")
+          ]
+          $ \(i, e) -> do
+            let e' = Just (ident # e)
+            parseM "Identifier" i `shouldBe` e'
+            parseM "Identifier" ("\"" ++ e ++ "\"") `shouldBe` e'
 
     describe "nixKeywords" $ do
       it "are quoted" $ forM_ nixKeywords $ \str -> do