Support Inlay hints for record wildcards

[jetjinser]

resolve #4211.

This PR adds the feature to provide explicit records by inlay hints.

The inlay hints are located after dotdot and have left padding, It also provides textEdit, which is consistent with the textEdit of code actions.

e.g

data MyRec = MyRec
  { foo :: Int
  , bar :: Int
  , baz :: Char
  }

convertMe :: MyRec -> String
convertMe MyRec {foo, ..<inlay> bar, baz</inlay>} = show foo ++ show bar ++ show baz

MyRec {foo, .. bar, baz}
  _paddingLeft^  | |  |
        part  |1 |2|3 |

part1: bar
part2: ,
part3: baz

[jetjinser]

I pushed some commits but it's broken on GHC 9.10.1, I'm working on fixing it.

[jetjinser]

I have spent a lot of time trying to fix the problem in higher GHC versions, but so far I can't figure out how to solve it.

The failed tests are HsExpanded1 and HsExpanded2.

I tested it in GHC 9.6.5 and 9.10.1. In 9.6.5, there are MyRec { .. } and MyRec { foo = foo } in tcg_binds, but in 9.10.1 there is only MyRec { foo = foo }.

MyRec { .. } should be processed in this function. But without MyRec { .. } (9.10.1), no records will be found.

haskell-language-server/plugins/hls-explicit-record-fields-plugin/src/Ide/Plugin/ExplicitFields.hs

Lines 496 to 503 in 96a2550

	getRecPatterns :: LPat GhcTc -> ([RecordInfo], Bool)
	getRecPatterns conPat@(conPatDetails . unLoc -> Just (RecCon flds))
	| isJust (rec_dotdot flds) = (mkRecInfo conPat, False)
	where
	mkRecInfo :: LPat GhcTc -> [RecordInfo]
	mkRecInfo pat =
	[ RecordInfoPat realSpan' (unLoc pat) | RealSrcSpan realSpan' _ <- [ getLoc pat ]]
	getRecPatterns _ = ([], False)

Please take a look, thanks! @wz1000, @fendor.

[fendor]

@jetjinser Sorry for the delay! I spent a little bit of time on this and while I cannot really tell you what's going wrong, I think this is either a bug in our HLS parsing/type checking pipeline or straight-up a GHC bug.

For example, the following Unused2.hs works completely fine:

{-# LANGUAGE RecordWildCards #-}
-- {-# LANGUAGE RebindableSyntax #-}
{-# LANGUAGE NamedFieldPuns #-}

module HsExpanded2 where
import Prelude

-- ifThenElse :: Int -> Int -> Int ->  Int
-- ifThenElse x y z = x + y + z

data MyRec = MyRec
  { foo :: Int }

data YourRec = YourRec
  { bar :: Bool }

myRecExample = MyRec 5

yourRecExample = YourRec True

convertMe :: Int
convertMe =
  if (let MyRec {..} = myRecExample
          YourRec {..} = yourRecExample
      in bar) then 1 else 2

However, this does also not work:

convertMe :: Int
convertMe =
    (let MyRec {..} = myRecExample
         YourRec {..} = yourRecExample
     in bar) + 1 + 2

I tested the file with ghc-exactprint and that the AST contains these nodes (which is what we are looking for):

                             (RecCon
                             (HsRecFields
                              []
                              (Just
                               (L
                                (EpaSpan { 24:20-21 })
                                (RecFieldsDotDot
                                 (0))))))))

That means that at least the parser is accurate.

My suggestion is to mark this test as broken for GHC 9.10.1 and move on for now.

[fendor]

I found something else, take this ast representation of the tcg_binds

Found an expr: if (let
      MyRec {..} = myRecExample
      YourRec {..} = yourRecExample
    in bar_azh) then
    1
else
    2
(L
 (EpAnn
  (EpaSpan { (23,3)-(25,27) })
  (AnnListItem
   [])
  (EpaComments
   []))
 (XExpr
  (ExpandedThingTc
   (OrigExpr
    (HsIf
     (NoExtField)
     (L
      (EpAnn
       (EpaSpan { (23,6)-(25,13) })
       (AnnListItem
        [])
       (EpaComments
        []))
      (HsPar
       (NoExtField)
       (L
        (EpAnn
         (EpaSpan { (23,7)-(25,12) })
         (AnnListItem
          [])
         (EpaComments
          []))
        (HsLet
         (NoExtField)
         (HsValBinds
          (EpAnn
           (EpaSpan { (23,11)-(24,39) })
           (AnnList
            (Just
             (EpaSpan { (23,11)-(24,39) }))
            (Nothing)
            (Nothing)
            []
            [])
           (EpaComments
            []))
          (XValBindsLR
           (NValBinds
            [((,)
              (NonRecursive)
              {Bag(LocatedA (HsBind Name)):
               [(L
                 (EpAnn
                  (EpaSpan { 24:11-39 })
                  (AnnListItem
                   [])
                  (EpaComments
                   []))
                 (PatBind
                  {NameSet:
                   [{Name: YourRec}
                   ,{Name: bar}
                   ,{Name: yourRecExample}]}
                  (L
                   (EpAnn
                    (EpaSpan { 24:11-22 })
                    (AnnListItem
                     [])
                    (EpaComments
                     []))
                   (ConPat
                    (NoExtField)
                    (L
                     (EpAnn
                      (EpaSpan { 24:11-17 })
                      (NameAnnTrailing
                       [])
                      (EpaComments
                       []))
                     {Name: YourRec})
                    (RecCon
                     (HsRecFields
                      [(L
                        (EpAnn
                         (EpaSpan { 24:20-21 })
                         (AnnListItem
                          [])
                         (EpaComments
                          []))
                        (HsFieldBind
                         []
                         (L
                          (EpAnn
                           (EpaSpan { 24:20-21 })
                           (AnnListItem
                            [])
                           (EpaComments
                            []))
                          (FieldOcc
                           {Name: bar}
                           (L
                            (EpAnn
                             (EpaSpan { 24:20-21 })
                             (NameAnnTrailing
                              [])
                             (EpaComments
                              []))
                            (Unqual
                             {OccName: bar}))))
                         (L
                          (EpAnn
                           (EpaSpan { 24:20-21 })
                           (AnnListItem
                            [])
                           (EpaComments
                            []))
                          (VarPat
                           (NoExtField)
                           (L
                            (EpAnn
                             (EpaSpan { 24:20-21 })
                             (NameAnnTrailing
                              [])
                             (EpaComments
                              []))
                            {Name: bar_azh})))
                         (False)))]
                      (Just
                       (L
                        (EpaSpan { 24:20-21 })
                        (RecFieldsDotDot
                         (0))))))))

It looks like getRecCons (unLoc -> XExpr (ExpandedThingTc a _)) = (collectRecords a, True) doesn't quite work as intended. Changing it to collectRecords a, False) seems to be working.

FYI, I am using ghc-exactprints showAst to create these lisp like structures.

Thus, I am taking back my prior conjecture, this is unlikely to be a HLS or GHC bug :)

[fendor]

Thanks, this looks quite nice already! Some small nitpicks and proposed changes :)

[fendor]

This looks good to me now :)