Fixes

Author: wz1000

ghcide/src/Development/IDE/GHC/Compat.hs

@@ -610,13 +610,16 @@ data GhcVersion
   | GHC90
   | GHC92
   | GHC94
+  | GHC96
   deriving (Eq, Ord, Show)
 
 ghcVersionStr :: String
 ghcVersionStr = VERSION_ghc
 
 ghcVersion :: GhcVersion
-#if MIN_VERSION_GLASGOW_HASKELL(9,4,0,0)
+#if MIN_VERSION_GLASGOW_HASKELL(9,6,0,0)
+ghcVersion = GHC96
+#elif MIN_VERSION_GLASGOW_HASKELL(9,4,0,0)
 ghcVersion = GHC94
 #elif MIN_VERSION_GLASGOW_HASKELL(9,2,0,0)
 ghcVersion = GHC92

plugins/hls-refactor-plugin/src/Development/IDE/Plugin/CodeAction.hs

@@ -826,43 +826,49 @@ suggestAddTypeAnnotationToSatisfyConstraints sourceOpt Diagnostic{_range=_range,
 --       In the expression: seq "test" seq "test" (traceShow "test")
 --       In an equation for ‘f’:
 --          f = seq "test" seq "test" (traceShow "test")
+--
     | Just [ty, lit] <- matchRegexUnifySpaces _message (pat False False True False)
-                        <|> matchRegexUnifySpaces _message (pat False False False True)
-                        <|> matchRegexUnifySpaces _message (pat False False False False)
-            = codeEdit ty lit (makeAnnotatedLit ty lit)
+                    <|> matchRegexUnifySpaces _message (pat False False False True)
+                    <|> matchRegexUnifySpaces _message (pat False False False False)
+
+            = codeEdit _range ty lit (makeAnnotatedLit ty lit)
     | Just source <- sourceOpt
-    , Just [ty, lit] <- matchRegexUnifySpaces _message (pat True True False False)
-            = let lit' = makeAnnotatedLit ty lit;
-                  tir = textInRange _range source
-              in codeEdit ty lit (T.replace lit lit' tir)
+    , Just [ty, lit, srcspan] <- matchRegexUnifySpaces _message (pat True True False False)
+    , range <- case [ x | (x,"") <- readSrcSpan (T.unpack srcspan)] of
+                 [s] -> let x = realSrcSpanToRange s
+                   in x{_end = (_end x){_character = succ (_character (_end x))}}
+                 _ -> error "bug in srcspan parser"
+    = let lit' = makeAnnotatedLit ty lit;
+          tir = textInRange range source
+      in codeEdit range ty lit (T.replace lit lit' tir)
     | otherwise = []
     where
       makeAnnotatedLit ty lit = "(" <> lit <> " :: " <> ty <> ")"
 #if MIN_VERSION_ghc(9,4,0)
       pat multiple at inArg inExpr = T.concat [ ".*Defaulting the type variable "
                                        , ".*to type ‘([^ ]+)’ "
                                        , "in the following constraint"
-                                       , if multiple then "s" else ""
+                                       , if multiple then "s" else " "
                                        , ".*arising from the literal ‘(.+)’"
                                        , if inArg then ".+In the.+argument" else ""
-                                       , if at then ".+at" else ""
+                                       , if at then ".+at ([^ ]*)" else ""
                                        , if inExpr then ".+In the expression" else ""
                                        , ".+In the expression"
                                        ]
 #else
       pat multiple at inArg inExpr = T.concat [ ".*Defaulting the following constraint"
-                                       , if multiple then "s" else ""
+                                       , if multiple then "s" else " "
                                        , " to type ‘([^ ]+)’ "
                                        , ".*arising from the literal ‘(.+)’"
                                        , if inArg then ".+In the.+argument" else ""
-                                       , if at then ".+at" else ""
+                                       , if at then ".+at ([^ ]*)" else ""
                                        , if inExpr then ".+In the expression" else ""
                                        , ".+In the expression"
                                        ]
 #endif
-      codeEdit ty lit replacement =
+      codeEdit range ty lit replacement =
         let title = "Add type annotation ‘" <> ty <> "’ to ‘" <> lit <> "’"
-            edits = [TextEdit _range replacement]
+            edits = [TextEdit range replacement]
         in  [( title, edits )]
 
 -- | GHC strips out backticks in case of infix functions as well as single quote
@@ -967,7 +973,7 @@ suggestExtendImport :: ExportsMap -> ParsedSource -> Diagnostic -> [(T.Text, Cod
 suggestExtendImport exportsMap (L _ HsModule {hsmodImports}) Diagnostic{_range=_range,..}
     | Just [binding, mod, srcspan] <-
       matchRegexUnifySpaces _message
-      "Perhaps you want to add ‘([^’]*)’ to the import list in the import of ‘([^’]*)’ *\\((.*)\\).$"
+      "Perhaps you want to add ‘([^’]*)’ to the import list in the import of ‘([^’]*)’ *\\((.*)\\)."
     = suggestions hsmodImports binding mod srcspan
     | Just (binding, mod_srcspan) <-
       matchRegExMultipleImports _message
@@ -1217,8 +1223,8 @@ suggestConstraint df (makeDeltaAst -> parsedModule) diag@Diagnostic {..}
     where
       findMissingConstraint :: T.Text -> Maybe T.Text
       findMissingConstraint t =
-        let regex = "(No instance for|Could not deduce) \\((.+)\\) arising from" -- a use of / a do statement
-            regexImplicitParams = "Could not deduce: (\\?.+) arising from a use of"
+        let regex = "(No instance for|Could not deduce) \\(?‘?([^’)]+)’?\\)? arising from" -- a use of / a do statement
+            regexImplicitParams = "Could not deduce:? ‘?(\\?[^’]+)’? arising from a use of"
             match = matchRegexUnifySpaces t regex
             matchImplicitParams = matchRegexUnifySpaces t regexImplicitParams
         in match <|> matchImplicitParams <&> last