{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeepSubsumption #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ViewPatterns #-}

-- | This module allows us to diff two 'ParseResult's.
module Ormolu.Diff.ParseResult
  ( ParseResultDiff (..),
    diffParseResult,
  )
where

import Data.ByteString (ByteString)
import Data.Char (isSpace)
import Data.Foldable
import Data.Function
import Data.Generics
import Data.List (sortOn)
import Data.Text qualified as T
import GHC.Data.FastString (FastString)
import GHC.Hs
import GHC.Types.SourceText
import GHC.Types.SrcLoc
import Ormolu.Config.Gen (ImportGrouping (ImportGroupSingle))
import Ormolu.Imports (normalizeImports)
import Ormolu.Parser.CommentStream
import Ormolu.Parser.Result
import Ormolu.Utils
import Type.Reflection qualified as TR

-- | Result of comparing two 'ParseResult's.
data ParseResultDiff
  = -- | Two parse results are the same
    Same
  | -- | Two parse results differ
    Different [RealSrcSpan]
  deriving (Int -> ParseResultDiff -> ShowS
[ParseResultDiff] -> ShowS
ParseResultDiff -> String
(Int -> ParseResultDiff -> ShowS)
-> (ParseResultDiff -> String)
-> ([ParseResultDiff] -> ShowS)
-> Show ParseResultDiff
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ParseResultDiff -> ShowS
showsPrec :: Int -> ParseResultDiff -> ShowS
$cshow :: ParseResultDiff -> String
show :: ParseResultDiff -> String
$cshowList :: [ParseResultDiff] -> ShowS
showList :: [ParseResultDiff] -> ShowS
Show)

instance Semigroup ParseResultDiff where
  ParseResultDiff
Same <> :: ParseResultDiff -> ParseResultDiff -> ParseResultDiff
<> ParseResultDiff
a = ParseResultDiff
a
  ParseResultDiff
a <> ParseResultDiff
Same = ParseResultDiff
a
  Different [RealSrcSpan]
xs <> Different [RealSrcSpan]
ys = [RealSrcSpan] -> ParseResultDiff
Different ([RealSrcSpan]
xs [RealSrcSpan] -> [RealSrcSpan] -> [RealSrcSpan]
forall a. [a] -> [a] -> [a]
++ [RealSrcSpan]
ys)

instance Monoid ParseResultDiff where
  mempty :: ParseResultDiff
mempty = ParseResultDiff
Same

-- | Return 'Diff' of two 'ParseResult's.
diffParseResult ::
  ParseResult ->
  ParseResult ->
  ParseResultDiff
diffParseResult :: ParseResult -> ParseResult -> ParseResultDiff
diffParseResult
  ParseResult
    { prCommentStream :: ParseResult -> CommentStream
prCommentStream = CommentStream
cstream0,
      prParsedSource :: ParseResult -> HsModule GhcPs
prParsedSource = HsModule GhcPs
hs0
    }
  ParseResult
    { prCommentStream :: ParseResult -> CommentStream
prCommentStream = CommentStream
cstream1,
      prParsedSource :: ParseResult -> HsModule GhcPs
prParsedSource = HsModule GhcPs
hs1
    } =
    CommentStream -> CommentStream -> ParseResultDiff
diffCommentStream CommentStream
cstream0 CommentStream
cstream1
      ParseResultDiff -> ParseResultDiff -> ParseResultDiff
forall a. Semigroup a => a -> a -> a
<> HsModule GhcPs -> HsModule GhcPs -> ParseResultDiff
diffHsModule
        HsModule GhcPs
hs0 {hsmodImports = concat . normalizeImports False mempty ImportGroupSingle $ hsmodImports hs0}
        HsModule GhcPs
hs1 {hsmodImports = concat . normalizeImports False mempty ImportGroupSingle $ hsmodImports hs1}

diffCommentStream :: CommentStream -> CommentStream -> ParseResultDiff
diffCommentStream :: CommentStream -> CommentStream -> ParseResultDiff
diffCommentStream (CommentStream [LComment]
cs) (CommentStream [LComment]
cs')
  | [LComment] -> [Text]
forall {l}. [GenLocated l Comment] -> [Text]
commentLines [LComment]
cs [Text] -> [Text] -> Bool
forall a. Eq a => a -> a -> Bool
== [LComment] -> [Text]
forall {l}. [GenLocated l Comment] -> [Text]
commentLines [LComment]
cs' = ParseResultDiff
Same
  | Bool
otherwise = [RealSrcSpan] -> ParseResultDiff
Different []
  where
    commentLines :: [GenLocated l Comment] -> [Text]
commentLines = (GenLocated l Comment -> [Text])
-> [GenLocated l Comment] -> [Text]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (NonEmpty Text -> [Text]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (NonEmpty Text -> [Text])
-> (GenLocated l Comment -> NonEmpty Text)
-> GenLocated l Comment
-> [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Comment -> NonEmpty Text
unComment (Comment -> NonEmpty Text)
-> (GenLocated l Comment -> Comment)
-> GenLocated l Comment
-> NonEmpty Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenLocated l Comment -> Comment
forall l e. GenLocated l e -> e
unLoc)

-- | Compare two modules for equality disregarding certain semantically
-- irrelevant features like exact print annotations.
diffHsModule :: HsModule GhcPs -> HsModule GhcPs -> ParseResultDiff
diffHsModule :: HsModule GhcPs -> HsModule GhcPs -> ParseResultDiff
diffHsModule = HsModule GhcPs -> HsModule GhcPs -> ParseResultDiff
HsModule GhcPs -> GenericQ ParseResultDiff
GenericQ (GenericQ ParseResultDiff)
genericQuery
  where
    genericQuery :: GenericQ (GenericQ ParseResultDiff)
    genericQuery :: GenericQ (GenericQ ParseResultDiff)
genericQuery a
x a
y
      -- 'ByteString' implements 'Data' instance manually and does not
      -- implement 'toConstr', so we have to deal with it in a special way.
      | Just ByteString
x' <- a -> Maybe ByteString
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a
x,
        Just ByteString
y' <- a -> Maybe ByteString
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a
y =
          if ByteString
x' ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== (ByteString
y' :: ByteString)
            then ParseResultDiff
Same
            else [RealSrcSpan] -> ParseResultDiff
Different []
      | Just SomeTypeRep
rep <- a -> Maybe SomeTypeRep
forall a. Typeable a => a -> Maybe SomeTypeRep
isEpTokenish a
x,
        Just SomeTypeRep
rep' <- a -> Maybe SomeTypeRep
forall a. Typeable a => a -> Maybe SomeTypeRep
isEpTokenish a
y =
          -- Only check whether the Ep(Uni)Tokens are of the same type; don't
          -- look at the actual payload (e.g. the location).
          if SomeTypeRep
rep SomeTypeRep -> SomeTypeRep -> Bool
forall a. Eq a => a -> a -> Bool
== SomeTypeRep
rep' then ParseResultDiff
Same else [RealSrcSpan] -> ParseResultDiff
Different []
      | a -> SomeTypeRep
forall a. Typeable a => a -> SomeTypeRep
typeOf a
x SomeTypeRep -> SomeTypeRep -> Bool
forall a. Eq a => a -> a -> Bool
== a -> SomeTypeRep
forall a. Typeable a => a -> SomeTypeRep
typeOf a
y,
        a -> Constr
forall a. Data a => a -> Constr
toConstr a
x Constr -> Constr -> Bool
forall a. Eq a => a -> a -> Bool
== a -> Constr
forall a. Data a => a -> Constr
toConstr a
y =
          [ParseResultDiff] -> ParseResultDiff
forall a. Monoid a => [a] -> a
mconcat ([ParseResultDiff] -> ParseResultDiff)
-> [ParseResultDiff] -> ParseResultDiff
forall a b. (a -> b) -> a -> b
$
            GenericQ (GenericQ ParseResultDiff)
-> GenericQ (GenericQ [ParseResultDiff])
forall r. GenericQ (GenericQ r) -> GenericQ (GenericQ [r])
gzipWithQ
              ( a -> a -> ParseResultDiff
a -> GenericQ ParseResultDiff
GenericQ (GenericQ ParseResultDiff)
genericQuery
                  -- EPA-related
                  (a -> a -> ParseResultDiff)
-> (SrcSpan -> a -> ParseResultDiff) -> a -> a -> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` forall a. Typeable a => a -> GenericQ ParseResultDiff
considerEqual @SrcSpan
                  (a -> a -> ParseResultDiff)
-> (forall e. Data e => EpAnn e -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall d (t :: * -> *) q.
(Data d, Typeable t) =>
(d -> q) -> (forall e. Data e => t e -> q) -> d -> q
`ext1Q` EpAnn e -> a -> ParseResultDiff
forall e. Data e => EpAnn e -> a -> ParseResultDiff
forall a b. EpAnn a -> b -> ParseResultDiff
epAnnEq
                  (a -> a -> ParseResultDiff)
-> (SourceText -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` forall a. Typeable a => a -> GenericQ ParseResultDiff
considerEqual @SourceText
                  (a -> a -> ParseResultDiff)
-> (EpAnnComments -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` forall a. Typeable a => a -> GenericQ ParseResultDiff
considerEqual @EpAnnComments -- ~ XCGRHSs GhcPs
                  (a -> a -> ParseResultDiff)
-> (EpaLocation -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` forall a. Typeable a => a -> GenericQ ParseResultDiff
considerEqual @EpaLocation
                  (a -> a -> ParseResultDiff)
-> (Maybe EpaLocation -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` forall a. Typeable a => a -> GenericQ ParseResultDiff
considerEqual @(Maybe EpaLocation)
                  (a -> a -> ParseResultDiff)
-> (EpLayout -> a -> ParseResultDiff) -> a -> a -> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` forall a. Typeable a => a -> GenericQ ParseResultDiff
considerEqual @EpLayout
                  (a -> a -> ParseResultDiff)
-> (AnnSig -> a -> ParseResultDiff) -> a -> a -> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` forall a. Typeable a => a -> GenericQ ParseResultDiff
considerEqual @AnnSig
                  (a -> a -> ParseResultDiff)
-> (HsRuleAnn -> a -> ParseResultDiff) -> a -> a -> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` forall a. Typeable a => a -> GenericQ ParseResultDiff
considerEqual @HsRuleAnn
                  (a -> a -> ParseResultDiff)
-> (EpLinearArrow -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` forall a. Typeable a => a -> GenericQ ParseResultDiff
considerEqual @EpLinearArrow
                  (a -> a -> ParseResultDiff)
-> (AnnSynDecl -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` forall a. Typeable a => a -> GenericQ ParseResultDiff
considerEqual @AnnSynDecl
                  (a -> a -> ParseResultDiff)
-> (IsUnicodeSyntax -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` forall a. Typeable a => a -> GenericQ ParseResultDiff
considerEqual @IsUnicodeSyntax
                  -- FastString (for example for string literals)
                  (a -> a -> ParseResultDiff)
-> (FastString -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` (FastString -> FastString -> Bool)
-> FastString -> GenericQ ParseResultDiff
forall {t}.
Typeable t =>
(t -> t -> Bool) -> t -> GenericQ ParseResultDiff
considerEqualVia' (forall a. Eq a => a -> a -> Bool
(==) @FastString)
                  -- Haddock strings
                  (a -> a -> ParseResultDiff)
-> (HsDocString -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` HsDocString -> a -> ParseResultDiff
HsDocString -> GenericQ ParseResultDiff
hsDocStringEq
                  -- Whether imports are pre- or post-qualified
                  (a -> a -> ParseResultDiff)
-> (ImportDeclQualifiedStyle -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` ImportDeclQualifiedStyle -> a -> ParseResultDiff
ImportDeclQualifiedStyle -> GenericQ ParseResultDiff
importDeclQualifiedStyleEq
                  -- Whether a class has an empty context
                  (a -> a -> ParseResultDiff)
-> (TyClDecl GhcPs -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` TyClDecl GhcPs -> a -> ParseResultDiff
TyClDecl GhcPs -> GenericQ ParseResultDiff
classDeclCtxEq
                  -- Whether there are parens around a derived type class
                  (a -> a -> ParseResultDiff)
-> (DerivClauseTys GhcPs -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` DerivClauseTys GhcPs -> a -> ParseResultDiff
DerivClauseTys GhcPs -> GenericQ ParseResultDiff
derivedTyClsEq
                  (a -> a -> ParseResultDiff)
-> (HsType GhcPs -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` HsType GhcPs -> a -> ParseResultDiff
HsType GhcPs -> GenericQ ParseResultDiff
typeEq
                  (a -> a -> ParseResultDiff)
-> (HsDataDefn GhcPs -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` HsDataDefn GhcPs -> a -> ParseResultDiff
HsDataDefn GhcPs -> GenericQ ParseResultDiff
dataDeclEq
                  (a -> a -> ParseResultDiff)
-> (ConDecl GhcPs -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall a b r.
(Typeable a, Typeable b) =>
(a -> r) -> (b -> r) -> a -> r
`extQ` ConDecl GhcPs -> a -> ParseResultDiff
ConDecl GhcPs -> GenericQ ParseResultDiff
conDeclEq
                  -- For better error messages
                  (a -> a -> ParseResultDiff)
-> (forall d1 d2.
    (Data d1, Data d2) =>
    GenLocated d1 d2 -> a -> ParseResultDiff)
-> a
-> a
-> ParseResultDiff
forall d (t :: * -> * -> *) q.
(Data d, Typeable t) =>
(d -> q)
-> (forall d1 d2. (Data d1, Data d2) => t d1 d2 -> q) -> d -> q
`ext2Q` GenLocated d1 d2 -> a -> ParseResultDiff
GenLocated d1 d2 -> GenericQ ParseResultDiff
forall d1 d2.
(Data d1, Data d2) =>
GenLocated d1 d2 -> a -> ParseResultDiff
forall e0 e1.
(Data e0, Data e1) =>
GenLocated e0 e1 -> GenericQ ParseResultDiff
forLocated
              )
              a
x
              a
y
      | Bool
otherwise = [RealSrcSpan] -> ParseResultDiff
Different []

    -- Return the 'TR.SomeTypeRep' of the type of the given value if it is an
    -- 'EpToken', an 'EpUniToken', or a list of these.
    isEpTokenish :: (Typeable a) => a -> Maybe TR.SomeTypeRep
    isEpTokenish :: forall a. Typeable a => a -> Maybe SomeTypeRep
isEpTokenish = (TypeRep a -> SomeTypeRep)
-> Maybe (TypeRep a) -> Maybe SomeTypeRep
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TypeRep a -> SomeTypeRep
forall k (a :: k). TypeRep a -> SomeTypeRep
TR.SomeTypeRep (Maybe (TypeRep a) -> Maybe SomeTypeRep)
-> (a -> Maybe (TypeRep a)) -> a -> Maybe SomeTypeRep
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeRep a -> Maybe (TypeRep a)
forall {k} (a :: k). TypeRep a -> Maybe (TypeRep a)
go (TypeRep a -> Maybe (TypeRep a))
-> (a -> TypeRep a) -> a -> Maybe (TypeRep a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> TypeRep a
forall a. Typeable a => a -> TypeRep a
TR.typeOf
      where
        go :: TR.TypeRep a -> Maybe (TR.TypeRep a)
        go :: forall {k} (a :: k). TypeRep a -> Maybe (TypeRep a)
go TypeRep a
rep = case TypeRep a
rep of
          TR.App TypeRep a
t TypeRep b
t'
            | Just a :~~: []
HRefl <- TypeRep a -> TypeRep [] -> Maybe (a :~~: [])
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
TR.eqTypeRep TypeRep a
t (forall {k} (a :: k). Typeable a => TypeRep a
forall (a :: * -> *). Typeable a => TypeRep a
TR.typeRep @[]) ->
                TypeRep a -> TypeRep b -> TypeRep a
forall k2 (t :: k2) k1 (a :: k1 -> k2) (b :: k1).
(t ~ a b) =>
TypeRep a -> TypeRep b -> TypeRep t
TR.App TypeRep a
t (TypeRep b -> TypeRep a) -> Maybe (TypeRep b) -> Maybe (TypeRep a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TypeRep b -> Maybe (TypeRep b)
forall {k} (a :: k). TypeRep a -> Maybe (TypeRep a)
go TypeRep b
t'
          TR.App (TR.App TypeRep a
t TypeRep b
_) TypeRep b
_ ->
            TypeRep a
rep TypeRep a -> Maybe (a :~~: EpUniToken) -> Maybe (TypeRep a)
forall a b. a -> Maybe b -> Maybe a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ TypeRep a -> TypeRep EpUniToken -> Maybe (a :~~: EpUniToken)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
TR.eqTypeRep TypeRep a
t (forall {k} (a :: k). Typeable a => TypeRep a
forall (a :: Symbol -> Symbol -> *). Typeable a => TypeRep a
TR.typeRep @EpUniToken)
          TR.App TypeRep a
t TypeRep b
_ ->
            TypeRep a
rep TypeRep a -> Maybe (a :~~: EpToken) -> Maybe (TypeRep a)
forall a b. a -> Maybe b -> Maybe a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ TypeRep a -> TypeRep EpToken -> Maybe (a :~~: EpToken)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
TR.eqTypeRep TypeRep a
t (forall {k} (a :: k). Typeable a => TypeRep a
forall (a :: Symbol -> *). Typeable a => TypeRep a
TR.typeRep @EpToken)
          TypeRep a
_ -> Maybe (TypeRep a)
forall a. Maybe a
Nothing

    considerEqualVia ::
      forall a.
      (Typeable a) =>
      (a -> a -> ParseResultDiff) ->
      a ->
      GenericQ ParseResultDiff
    considerEqualVia :: forall a.
Typeable a =>
(a -> a -> ParseResultDiff) -> a -> GenericQ ParseResultDiff
considerEqualVia a -> a -> ParseResultDiff
f a
x (a -> Maybe a
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast -> Just a
x') = a -> a -> ParseResultDiff
f a
x a
x'
    considerEqualVia a -> a -> ParseResultDiff
_ a
_ a
_ = [RealSrcSpan] -> ParseResultDiff
Different []

    considerEqualVia' :: (t -> t -> Bool) -> t -> GenericQ ParseResultDiff
considerEqualVia' t -> t -> Bool
f =
      (t -> t -> ParseResultDiff) -> t -> GenericQ ParseResultDiff
forall a.
Typeable a =>
(a -> a -> ParseResultDiff) -> a -> GenericQ ParseResultDiff
considerEqualVia ((t -> t -> ParseResultDiff) -> t -> GenericQ ParseResultDiff)
-> (t -> t -> ParseResultDiff) -> t -> GenericQ ParseResultDiff
forall a b. (a -> b) -> a -> b
$ \t
x t
x' -> if t -> t -> Bool
f t
x t
x' then ParseResultDiff
Same else [RealSrcSpan] -> ParseResultDiff
Different []

    considerEqualOn ::
      (Typeable a, Data b) =>
      (a -> b) ->
      a ->
      GenericQ ParseResultDiff
    considerEqualOn :: forall a b.
(Typeable a, Data b) =>
(a -> b) -> a -> GenericQ ParseResultDiff
considerEqualOn a -> b
f = (a -> a -> ParseResultDiff) -> a -> GenericQ ParseResultDiff
forall a.
Typeable a =>
(a -> a -> ParseResultDiff) -> a -> GenericQ ParseResultDiff
considerEqualVia (b -> b -> ParseResultDiff
b -> GenericQ ParseResultDiff
GenericQ (GenericQ ParseResultDiff)
genericQuery (b -> b -> ParseResultDiff)
-> (a -> b) -> a -> a -> ParseResultDiff
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` a -> b
f)

    considerEqual :: forall a. (Typeable a) => a -> GenericQ ParseResultDiff
    considerEqual :: forall a. Typeable a => a -> GenericQ ParseResultDiff
considerEqual = (a -> a -> ParseResultDiff) -> a -> GenericQ ParseResultDiff
forall a.
Typeable a =>
(a -> a -> ParseResultDiff) -> a -> GenericQ ParseResultDiff
considerEqualVia ((a -> a -> ParseResultDiff) -> a -> GenericQ ParseResultDiff)
-> (a -> a -> ParseResultDiff) -> a -> GenericQ ParseResultDiff
forall a b. (a -> b) -> a -> b
$ \a
_ a
_ -> ParseResultDiff
Same

    epAnnEq :: EpAnn a -> b -> ParseResultDiff
    epAnnEq :: forall a b. EpAnn a -> b -> ParseResultDiff
epAnnEq EpAnn a
_ b
_ = ParseResultDiff
Same

    importDeclQualifiedStyleEq :: ImportDeclQualifiedStyle -> GenericQ ParseResultDiff
importDeclQualifiedStyleEq = (ImportDeclQualifiedStyle -> ImportDeclQualifiedStyle -> Bool)
-> ImportDeclQualifiedStyle -> GenericQ ParseResultDiff
forall {t}.
Typeable t =>
(t -> t -> Bool) -> t -> GenericQ ParseResultDiff
considerEqualVia' ImportDeclQualifiedStyle -> ImportDeclQualifiedStyle -> Bool
f
      where
        f :: ImportDeclQualifiedStyle -> ImportDeclQualifiedStyle -> Bool
f ImportDeclQualifiedStyle
QualifiedPre ImportDeclQualifiedStyle
QualifiedPost = Bool
True
        f ImportDeclQualifiedStyle
QualifiedPost ImportDeclQualifiedStyle
QualifiedPre = Bool
True
        f ImportDeclQualifiedStyle
x ImportDeclQualifiedStyle
x' = ImportDeclQualifiedStyle
x ImportDeclQualifiedStyle -> ImportDeclQualifiedStyle -> Bool
forall a. Eq a => a -> a -> Bool
== ImportDeclQualifiedStyle
x'

    hsDocStringEq :: HsDocString -> GenericQ ParseResultDiff
    hsDocStringEq :: HsDocString -> GenericQ ParseResultDiff
hsDocStringEq = (HsDocString -> HsDocString -> Bool)
-> HsDocString -> GenericQ ParseResultDiff
forall {t}.
Typeable t =>
(t -> t -> Bool) -> t -> GenericQ ParseResultDiff
considerEqualVia' ([Text] -> [Text] -> Bool
forall a. Eq a => a -> a -> Bool
(==) ([Text] -> [Text] -> Bool)
-> (HsDocString -> [Text]) -> HsDocString -> HsDocString -> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` ((Text -> Text) -> [Text] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map ((Char -> Bool) -> Text -> Text
T.dropWhile Char -> Bool
isSpace) ([Text] -> [Text])
-> (HsDocString -> [Text]) -> HsDocString -> [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> HsDocString -> [Text]
splitDocString Bool
True))

    forLocated ::
      (Data e0, Data e1) =>
      GenLocated e0 e1 ->
      GenericQ ParseResultDiff
    forLocated :: forall e0 e1.
(Data e0, Data e1) =>
GenLocated e0 e1 -> GenericQ ParseResultDiff
forLocated x :: GenLocated e0 e1
x@(L e0
mspn e1
_) a
y =
      (ParseResultDiff -> ParseResultDiff)
-> (SrcSpan -> ParseResultDiff -> ParseResultDiff)
-> Maybe SrcSpan
-> ParseResultDiff
-> ParseResultDiff
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ParseResultDiff -> ParseResultDiff
forall a. a -> a
id SrcSpan -> ParseResultDiff -> ParseResultDiff
appendSpan (e0 -> Maybe SrcSpan
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast (e0 -> Maybe SrcSpan)
-> (forall e. Data e => EpAnn e -> Maybe SrcSpan)
-> e0
-> Maybe SrcSpan
forall d (t :: * -> *) q.
(Data d, Typeable t) =>
(d -> q) -> (forall e. Data e => t e -> q) -> d -> q
`ext1Q` (SrcSpan -> Maybe SrcSpan
forall a. a -> Maybe a
Just (SrcSpan -> Maybe SrcSpan)
-> (EpAnn e -> SrcSpan) -> EpAnn e -> Maybe SrcSpan
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EpAnn e -> SrcSpan
forall ann. EpAnn ann -> SrcSpan
epAnnLoc) (e0 -> Maybe SrcSpan) -> e0 -> Maybe SrcSpan
forall a b. (a -> b) -> a -> b
$ e0
mspn) (GenLocated e0 e1 -> GenericQ ParseResultDiff
GenericQ (GenericQ ParseResultDiff)
genericQuery GenLocated e0 e1
x a
y)
      where
        epAnnLoc :: EpAnn ann -> SrcSpan
        epAnnLoc :: forall ann. EpAnn ann -> SrcSpan
epAnnLoc = EpAnn ann -> SrcSpan
forall a. HasLoc a => a -> SrcSpan
locA
    appendSpan :: SrcSpan -> ParseResultDiff -> ParseResultDiff
    appendSpan :: SrcSpan -> ParseResultDiff -> ParseResultDiff
appendSpan SrcSpan
s' d :: ParseResultDiff
d@(Different [RealSrcSpan]
ss) =
      case SrcSpan
s' of
        RealSrcSpan RealSrcSpan
s Maybe BufSpan
_ ->
          if Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ (RealSrcSpan -> Bool) -> [RealSrcSpan] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (RealSrcSpan -> RealSrcSpan -> Bool
`isRealSubspanOf` RealSrcSpan
s) [RealSrcSpan]
ss
            then [RealSrcSpan] -> ParseResultDiff
Different (RealSrcSpan
s RealSrcSpan -> [RealSrcSpan] -> [RealSrcSpan]
forall a. a -> [a] -> [a]
: [RealSrcSpan]
ss)
            else ParseResultDiff
d
        UnhelpfulSpan UnhelpfulSpanReason
_ -> ParseResultDiff
d
    appendSpan SrcSpan
_ ParseResultDiff
d = ParseResultDiff
d

    -- The order of contexts doesn't matter
    normalizeContext :: HsContext GhcPs -> HsContext GhcPs
    normalizeContext :: HsContext GhcPs -> HsContext GhcPs
normalizeContext = (GenLocated SrcSpanAnnA (HsType GhcPs) -> String)
-> [GenLocated SrcSpanAnnA (HsType GhcPs)]
-> [GenLocated SrcSpanAnnA (HsType GhcPs)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn GenLocated SrcSpanAnnA (HsType GhcPs) -> String
forall o. Outputable o => o -> String
showOutputable

    normalizeMContext :: Maybe (LHsContext GhcPs) -> Maybe (LHsContext GhcPs)
    normalizeMContext :: Maybe (LHsContext GhcPs) -> Maybe (LHsContext GhcPs)
normalizeMContext Maybe (LHsContext GhcPs)
Nothing = Maybe (LHsContext GhcPs)
Maybe
  (GenLocated SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType GhcPs)])
forall a. Maybe a
Nothing
    normalizeMContext (Just (L SrcSpanAnnC
_ [])) = Maybe (LHsContext GhcPs)
Maybe
  (GenLocated SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType GhcPs)])
forall a. Maybe a
Nothing
    normalizeMContext (Just (L SrcSpanAnnC
ann [GenLocated SrcSpanAnnA (HsType GhcPs)]
ctx)) = GenLocated SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType GhcPs)]
-> Maybe
     (GenLocated SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType GhcPs)])
forall a. a -> Maybe a
Just (SrcSpanAnnC
-> HsContext GhcPs -> GenLocated SrcSpanAnnC (HsContext GhcPs)
forall l e. l -> e -> GenLocated l e
L SrcSpanAnnC
ann (HsContext GhcPs -> GenLocated SrcSpanAnnC (HsContext GhcPs))
-> HsContext GhcPs -> GenLocated SrcSpanAnnC (HsContext GhcPs)
forall a b. (a -> b) -> a -> b
$ HsContext GhcPs -> HsContext GhcPs
normalizeContext HsContext GhcPs
[GenLocated SrcSpanAnnA (HsType GhcPs)]
ctx)

    typeEq :: HsType GhcPs -> GenericQ ParseResultDiff
    typeEq :: HsType GhcPs -> GenericQ ParseResultDiff
typeEq = (HsType GhcPs -> HsType GhcPs)
-> HsType GhcPs -> GenericQ ParseResultDiff
forall a b.
(Typeable a, Data b) =>
(a -> b) -> a -> GenericQ ParseResultDiff
considerEqualOn ((HsType GhcPs -> HsType GhcPs)
 -> HsType GhcPs -> GenericQ ParseResultDiff)
-> (HsType GhcPs -> HsType GhcPs)
-> HsType GhcPs
-> GenericQ ParseResultDiff
forall a b. (a -> b) -> a -> b
$ \case
      HsQualTy XQualTy GhcPs
ann LHsContext GhcPs
ctx LHsType GhcPs
body -> XQualTy GhcPs -> LHsContext GhcPs -> LHsType GhcPs -> HsType GhcPs
forall pass.
XQualTy pass -> LHsContext pass -> LHsType pass -> HsType pass
HsQualTy XQualTy GhcPs
ann (([GenLocated SrcSpanAnnA (HsType GhcPs)]
 -> [GenLocated SrcSpanAnnA (HsType GhcPs)])
-> GenLocated SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType GhcPs)]
-> GenLocated SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType GhcPs)]
forall a b.
(a -> b) -> GenLocated SrcSpanAnnC a -> GenLocated SrcSpanAnnC b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap HsContext GhcPs -> HsContext GhcPs
[GenLocated SrcSpanAnnA (HsType GhcPs)]
-> [GenLocated SrcSpanAnnA (HsType GhcPs)]
normalizeContext LHsContext GhcPs
GenLocated SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType GhcPs)]
ctx) LHsType GhcPs
body
      HsType GhcPs
ty -> HsType GhcPs
ty

    classDeclCtxEq :: TyClDecl GhcPs -> GenericQ ParseResultDiff
    classDeclCtxEq :: TyClDecl GhcPs -> GenericQ ParseResultDiff
classDeclCtxEq = (TyClDecl GhcPs -> TyClDecl GhcPs)
-> TyClDecl GhcPs -> GenericQ ParseResultDiff
forall a b.
(Typeable a, Data b) =>
(a -> b) -> a -> GenericQ ParseResultDiff
considerEqualOn ((TyClDecl GhcPs -> TyClDecl GhcPs)
 -> TyClDecl GhcPs -> GenericQ ParseResultDiff)
-> (TyClDecl GhcPs -> TyClDecl GhcPs)
-> TyClDecl GhcPs
-> GenericQ ParseResultDiff
forall a b. (a -> b) -> a -> b
$ \case
      ClassDecl {[LSig GhcPs]
LHsBinds GhcPs
[LDocDecl GhcPs]
[LTyFamDefltDecl GhcPs]
[LFamilyDecl GhcPs]
[LHsFunDep GhcPs]
Maybe (LHsContext GhcPs)
LexicalFixity
XClassDecl GhcPs
LIdP GhcPs
LHsQTyVars GhcPs
tcdCExt :: XClassDecl GhcPs
tcdCtxt :: Maybe (LHsContext GhcPs)
tcdLName :: LIdP GhcPs
tcdTyVars :: LHsQTyVars GhcPs
tcdFixity :: LexicalFixity
tcdFDs :: [LHsFunDep GhcPs]
tcdSigs :: [LSig GhcPs]
tcdMeths :: LHsBinds GhcPs
tcdATs :: [LFamilyDecl GhcPs]
tcdATDefs :: [LTyFamDefltDecl GhcPs]
tcdDocs :: [LDocDecl GhcPs]
tcdFixity :: forall pass. TyClDecl pass -> LexicalFixity
tcdTyVars :: forall pass. TyClDecl pass -> LHsQTyVars pass
tcdLName :: forall pass. TyClDecl pass -> LIdP pass
tcdDocs :: forall pass. TyClDecl pass -> [LDocDecl pass]
tcdATDefs :: forall pass. TyClDecl pass -> [LTyFamDefltDecl pass]
tcdATs :: forall pass. TyClDecl pass -> [LFamilyDecl pass]
tcdMeths :: forall pass. TyClDecl pass -> LHsBinds pass
tcdSigs :: forall pass. TyClDecl pass -> [LSig pass]
tcdFDs :: forall pass. TyClDecl pass -> [LHsFunDep pass]
tcdCtxt :: forall pass. TyClDecl pass -> Maybe (LHsContext pass)
tcdCExt :: forall pass. TyClDecl pass -> XClassDecl pass
..} -> ClassDecl {tcdCtxt :: Maybe (LHsContext GhcPs)
tcdCtxt = Maybe (LHsContext GhcPs) -> Maybe (LHsContext GhcPs)
normalizeMContext Maybe (LHsContext GhcPs)
tcdCtxt, [LSig GhcPs]
LHsBinds GhcPs
[LDocDecl GhcPs]
[LTyFamDefltDecl GhcPs]
[LFamilyDecl GhcPs]
[LHsFunDep GhcPs]
LexicalFixity
XClassDecl GhcPs
LIdP GhcPs
LHsQTyVars GhcPs
tcdCExt :: XClassDecl GhcPs
tcdLName :: LIdP GhcPs
tcdTyVars :: LHsQTyVars GhcPs
tcdFixity :: LexicalFixity
tcdFDs :: [LHsFunDep GhcPs]
tcdSigs :: [LSig GhcPs]
tcdMeths :: LHsBinds GhcPs
tcdATs :: [LFamilyDecl GhcPs]
tcdATDefs :: [LTyFamDefltDecl GhcPs]
tcdDocs :: [LDocDecl GhcPs]
tcdFixity :: LexicalFixity
tcdTyVars :: LHsQTyVars GhcPs
tcdLName :: LIdP GhcPs
tcdDocs :: [LDocDecl GhcPs]
tcdATDefs :: [LTyFamDefltDecl GhcPs]
tcdATs :: [LFamilyDecl GhcPs]
tcdMeths :: LHsBinds GhcPs
tcdSigs :: [LSig GhcPs]
tcdFDs :: [LHsFunDep GhcPs]
tcdCExt :: XClassDecl GhcPs
..}
      TyClDecl GhcPs
d -> TyClDecl GhcPs
d

    dataDeclEq :: HsDataDefn GhcPs -> GenericQ ParseResultDiff
    dataDeclEq :: HsDataDefn GhcPs -> GenericQ ParseResultDiff
dataDeclEq = (HsDataDefn GhcPs -> HsDataDefn GhcPs)
-> HsDataDefn GhcPs -> GenericQ ParseResultDiff
forall a b.
(Typeable a, Data b) =>
(a -> b) -> a -> GenericQ ParseResultDiff
considerEqualOn ((HsDataDefn GhcPs -> HsDataDefn GhcPs)
 -> HsDataDefn GhcPs -> GenericQ ParseResultDiff)
-> (HsDataDefn GhcPs -> HsDataDefn GhcPs)
-> HsDataDefn GhcPs
-> GenericQ ParseResultDiff
forall a b. (a -> b) -> a -> b
$ \case
      HsDataDefn {HsDeriving GhcPs
Maybe (LHsContext GhcPs)
Maybe (XRec GhcPs CType)
Maybe (LHsType GhcPs)
XCHsDataDefn GhcPs
DataDefnCons (LConDecl GhcPs)
dd_ext :: XCHsDataDefn GhcPs
dd_ctxt :: Maybe (LHsContext GhcPs)
dd_cType :: Maybe (XRec GhcPs CType)
dd_kindSig :: Maybe (LHsType GhcPs)
dd_cons :: DataDefnCons (LConDecl GhcPs)
dd_derivs :: HsDeriving GhcPs
dd_derivs :: forall pass. HsDataDefn pass -> HsDeriving pass
dd_cons :: forall pass. HsDataDefn pass -> DataDefnCons (LConDecl pass)
dd_kindSig :: forall pass. HsDataDefn pass -> Maybe (LHsKind pass)
dd_cType :: forall pass. HsDataDefn pass -> Maybe (XRec pass CType)
dd_ctxt :: forall pass. HsDataDefn pass -> Maybe (LHsContext pass)
dd_ext :: forall pass. HsDataDefn pass -> XCHsDataDefn pass
..} ->
        HsDataDefn
          { -- The order of classes in the context doesn't matter
            dd_ctxt :: Maybe (LHsContext GhcPs)
dd_ctxt = Maybe (LHsContext GhcPs) -> Maybe (LHsContext GhcPs)
normalizeMContext Maybe (LHsContext GhcPs)
dd_ctxt,
            -- The order of deriving clauses doesn't matter. Note: need to normalize before sorting, otherwise
            -- we'll get a different sort order!
            dd_derivs :: HsDeriving GhcPs
dd_derivs = (GenLocated EpAnnCO (HsDerivingClause GhcPs) -> String)
-> [GenLocated EpAnnCO (HsDerivingClause GhcPs)]
-> [GenLocated EpAnnCO (HsDerivingClause GhcPs)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn GenLocated EpAnnCO (HsDerivingClause GhcPs) -> String
forall o. Outputable o => o -> String
showOutputable (((GenLocated EpAnnCO (HsDerivingClause GhcPs)
 -> GenLocated EpAnnCO (HsDerivingClause GhcPs))
-> [GenLocated EpAnnCO (HsDerivingClause GhcPs)]
-> [GenLocated EpAnnCO (HsDerivingClause GhcPs)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((GenLocated EpAnnCO (HsDerivingClause GhcPs)
  -> GenLocated EpAnnCO (HsDerivingClause GhcPs))
 -> [GenLocated EpAnnCO (HsDerivingClause GhcPs)]
 -> [GenLocated EpAnnCO (HsDerivingClause GhcPs)])
-> ((HsDerivingClause GhcPs -> HsDerivingClause GhcPs)
    -> GenLocated EpAnnCO (HsDerivingClause GhcPs)
    -> GenLocated EpAnnCO (HsDerivingClause GhcPs))
-> (HsDerivingClause GhcPs -> HsDerivingClause GhcPs)
-> [GenLocated EpAnnCO (HsDerivingClause GhcPs)]
-> [GenLocated EpAnnCO (HsDerivingClause GhcPs)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HsDerivingClause GhcPs -> HsDerivingClause GhcPs)
-> GenLocated EpAnnCO (HsDerivingClause GhcPs)
-> GenLocated EpAnnCO (HsDerivingClause GhcPs)
forall a b.
(a -> b) -> GenLocated EpAnnCO a -> GenLocated EpAnnCO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap) HsDerivingClause GhcPs -> HsDerivingClause GhcPs
normalizeDerivingClause HsDeriving GhcPs
[GenLocated EpAnnCO (HsDerivingClause GhcPs)]
dd_derivs),
            Maybe (XRec GhcPs CType)
Maybe (LHsType GhcPs)
XCHsDataDefn GhcPs
DataDefnCons (LConDecl GhcPs)
dd_ext :: XCHsDataDefn GhcPs
dd_cType :: Maybe (XRec GhcPs CType)
dd_kindSig :: Maybe (LHsType GhcPs)
dd_cons :: DataDefnCons (LConDecl GhcPs)
dd_cons :: DataDefnCons (LConDecl GhcPs)
dd_kindSig :: Maybe (LHsType GhcPs)
dd_cType :: Maybe (XRec GhcPs CType)
dd_ext :: XCHsDataDefn GhcPs
..
          }

    conDeclEq :: ConDecl GhcPs -> GenericQ ParseResultDiff
    conDeclEq :: ConDecl GhcPs -> GenericQ ParseResultDiff
conDeclEq = (ConDecl GhcPs -> ConDecl GhcPs)
-> ConDecl GhcPs -> GenericQ ParseResultDiff
forall a b.
(Typeable a, Data b) =>
(a -> b) -> a -> GenericQ ParseResultDiff
considerEqualOn ((ConDecl GhcPs -> ConDecl GhcPs)
 -> ConDecl GhcPs -> GenericQ ParseResultDiff)
-> (ConDecl GhcPs -> ConDecl GhcPs)
-> ConDecl GhcPs
-> GenericQ ParseResultDiff
forall a b. (a -> b) -> a -> b
$ \case
      ConDeclGADT {Maybe (LHsContext GhcPs)
Maybe (LHsDoc GhcPs)
NonEmpty (LIdP GhcPs)
XConDeclGADT GhcPs
LHsType GhcPs
XRec GhcPs (HsOuterSigTyVarBndrs GhcPs)
HsConDeclGADTDetails GhcPs
con_g_ext :: XConDeclGADT GhcPs
con_names :: NonEmpty (LIdP GhcPs)
con_bndrs :: XRec GhcPs (HsOuterSigTyVarBndrs GhcPs)
con_mb_cxt :: Maybe (LHsContext GhcPs)
con_g_args :: HsConDeclGADTDetails GhcPs
con_res_ty :: LHsType GhcPs
con_doc :: Maybe (LHsDoc GhcPs)
con_doc :: forall pass. ConDecl pass -> Maybe (LHsDoc pass)
con_res_ty :: forall pass. ConDecl pass -> LHsType pass
con_g_args :: forall pass. ConDecl pass -> HsConDeclGADTDetails pass
con_mb_cxt :: forall pass. ConDecl pass -> Maybe (LHsContext pass)
con_bndrs :: forall pass. ConDecl pass -> XRec pass (HsOuterSigTyVarBndrs pass)
con_names :: forall pass. ConDecl pass -> NonEmpty (LIdP pass)
con_g_ext :: forall pass. ConDecl pass -> XConDeclGADT pass
..} -> ConDeclGADT {con_mb_cxt :: Maybe (LHsContext GhcPs)
con_mb_cxt = Maybe (LHsContext GhcPs) -> Maybe (LHsContext GhcPs)
normalizeMContext Maybe (LHsContext GhcPs)
con_mb_cxt, Maybe (LHsDoc GhcPs)
NonEmpty (LIdP GhcPs)
XConDeclGADT GhcPs
LHsType GhcPs
XRec GhcPs (HsOuterSigTyVarBndrs GhcPs)
HsConDeclGADTDetails GhcPs
con_g_ext :: XConDeclGADT GhcPs
con_names :: NonEmpty (LIdP GhcPs)
con_bndrs :: XRec GhcPs (HsOuterSigTyVarBndrs GhcPs)
con_g_args :: HsConDeclGADTDetails GhcPs
con_res_ty :: LHsType GhcPs
con_doc :: Maybe (LHsDoc GhcPs)
con_doc :: Maybe (LHsDoc GhcPs)
con_res_ty :: LHsType GhcPs
con_g_args :: HsConDeclGADTDetails GhcPs
con_bndrs :: XRec GhcPs (HsOuterSigTyVarBndrs GhcPs)
con_names :: NonEmpty (LIdP GhcPs)
con_g_ext :: XConDeclGADT GhcPs
..}
      ConDeclH98 {Bool
[LHsTyVarBndr Specificity GhcPs]
Maybe (LHsContext GhcPs)
Maybe (LHsDoc GhcPs)
XConDeclH98 GhcPs
LIdP GhcPs
HsConDeclH98Details GhcPs
con_doc :: forall pass. ConDecl pass -> Maybe (LHsDoc pass)
con_mb_cxt :: forall pass. ConDecl pass -> Maybe (LHsContext pass)
con_ext :: XConDeclH98 GhcPs
con_name :: LIdP GhcPs
con_forall :: Bool
con_ex_tvs :: [LHsTyVarBndr Specificity GhcPs]
con_mb_cxt :: Maybe (LHsContext GhcPs)
con_args :: HsConDeclH98Details GhcPs
con_doc :: Maybe (LHsDoc GhcPs)
con_args :: forall pass. ConDecl pass -> HsConDeclH98Details pass
con_ex_tvs :: forall pass. ConDecl pass -> [LHsTyVarBndr Specificity pass]
con_forall :: forall pass. ConDecl pass -> Bool
con_name :: forall pass. ConDecl pass -> LIdP pass
con_ext :: forall pass. ConDecl pass -> XConDeclH98 pass
..} -> ConDeclH98 {con_mb_cxt :: Maybe (LHsContext GhcPs)
con_mb_cxt = Maybe (LHsContext GhcPs) -> Maybe (LHsContext GhcPs)
normalizeMContext Maybe (LHsContext GhcPs)
con_mb_cxt, Bool
[LHsTyVarBndr Specificity GhcPs]
Maybe (LHsDoc GhcPs)
XConDeclH98 GhcPs
LIdP GhcPs
HsConDeclH98Details GhcPs
con_doc :: Maybe (LHsDoc GhcPs)
con_ext :: XConDeclH98 GhcPs
con_name :: LIdP GhcPs
con_forall :: Bool
con_ex_tvs :: [LHsTyVarBndr Specificity GhcPs]
con_args :: HsConDeclH98Details GhcPs
con_doc :: Maybe (LHsDoc GhcPs)
con_args :: HsConDeclH98Details GhcPs
con_ex_tvs :: [LHsTyVarBndr Specificity GhcPs]
con_forall :: Bool
con_name :: LIdP GhcPs
con_ext :: XConDeclH98 GhcPs
..}

    normalizeDerivingClause :: HsDerivingClause GhcPs -> HsDerivingClause GhcPs
    normalizeDerivingClause :: HsDerivingClause GhcPs -> HsDerivingClause GhcPs
normalizeDerivingClause HsDerivingClause {LDerivClauseTys GhcPs
deriv_clause_tys :: LDerivClauseTys GhcPs
deriv_clause_tys :: forall pass. HsDerivingClause pass -> LDerivClauseTys pass
deriv_clause_tys, Maybe (LDerivStrategy GhcPs)
XCHsDerivingClause GhcPs
deriv_clause_ext :: XCHsDerivingClause GhcPs
deriv_clause_strategy :: Maybe (LDerivStrategy GhcPs)
deriv_clause_strategy :: forall pass. HsDerivingClause pass -> Maybe (LDerivStrategy pass)
deriv_clause_ext :: forall pass. HsDerivingClause pass -> XCHsDerivingClause pass
..} =
      HsDerivingClause {deriv_clause_tys :: LDerivClauseTys GhcPs
deriv_clause_tys = (DerivClauseTys GhcPs -> DerivClauseTys GhcPs)
-> GenLocated SrcSpanAnnC (DerivClauseTys GhcPs)
-> GenLocated SrcSpanAnnC (DerivClauseTys GhcPs)
forall a b.
(a -> b) -> GenLocated SrcSpanAnnC a -> GenLocated SrcSpanAnnC b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DerivClauseTys GhcPs -> DerivClauseTys GhcPs
normalizeDerivClauseTys LDerivClauseTys GhcPs
GenLocated SrcSpanAnnC (DerivClauseTys GhcPs)
deriv_clause_tys, Maybe (LDerivStrategy GhcPs)
XCHsDerivingClause GhcPs
deriv_clause_ext :: XCHsDerivingClause GhcPs
deriv_clause_strategy :: Maybe (LDerivStrategy GhcPs)
deriv_clause_strategy :: Maybe (LDerivStrategy GhcPs)
deriv_clause_ext :: XCHsDerivingClause GhcPs
..}

    normalizeDerivClauseTys :: DerivClauseTys GhcPs -> DerivClauseTys GhcPs
    normalizeDerivClauseTys :: DerivClauseTys GhcPs -> DerivClauseTys GhcPs
normalizeDerivClauseTys (DctSingle XDctSingle GhcPs
ann LHsSigType GhcPs
ty) = XDctMulti GhcPs -> [LHsSigType GhcPs] -> DerivClauseTys GhcPs
forall pass.
XDctMulti pass -> [LHsSigType pass] -> DerivClauseTys pass
DctMulti XDctMulti GhcPs
XDctSingle GhcPs
ann [LHsSigType GhcPs
ty]
    -- The order of types in deriving clauses doesn't matter
    normalizeDerivClauseTys (DctMulti XDctMulti GhcPs
ann [LHsSigType GhcPs]
tys) = XDctMulti GhcPs -> [LHsSigType GhcPs] -> DerivClauseTys GhcPs
forall pass.
XDctMulti pass -> [LHsSigType pass] -> DerivClauseTys pass
DctMulti XDctMulti GhcPs
ann ((GenLocated SrcSpanAnnA (HsSigType GhcPs) -> String)
-> [GenLocated SrcSpanAnnA (HsSigType GhcPs)]
-> [GenLocated SrcSpanAnnA (HsSigType GhcPs)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn GenLocated SrcSpanAnnA (HsSigType GhcPs) -> String
forall o. Outputable o => o -> String
showOutputable [LHsSigType GhcPs]
[GenLocated SrcSpanAnnA (HsSigType GhcPs)]
tys)

    derivedTyClsEq :: DerivClauseTys GhcPs -> GenericQ ParseResultDiff
    derivedTyClsEq :: DerivClauseTys GhcPs -> GenericQ ParseResultDiff
derivedTyClsEq = (DerivClauseTys GhcPs -> DerivClauseTys GhcPs -> ParseResultDiff)
-> DerivClauseTys GhcPs -> GenericQ ParseResultDiff
forall a.
Typeable a =>
(a -> a -> ParseResultDiff) -> a -> GenericQ ParseResultDiff
considerEqualVia ((DerivClauseTys GhcPs -> DerivClauseTys GhcPs -> ParseResultDiff)
 -> DerivClauseTys GhcPs -> GenericQ ParseResultDiff)
-> (DerivClauseTys GhcPs
    -> DerivClauseTys GhcPs -> ParseResultDiff)
-> DerivClauseTys GhcPs
-> GenericQ ParseResultDiff
forall a b. (a -> b) -> a -> b
$ \DerivClauseTys GhcPs
lc DerivClauseTys GhcPs
rc -> DerivClauseTys GhcPs -> GenericQ ParseResultDiff
GenericQ (GenericQ ParseResultDiff)
genericQuery (DerivClauseTys GhcPs -> DerivClauseTys GhcPs
normalizeDerivClauseTys DerivClauseTys GhcPs
lc) (DerivClauseTys GhcPs -> DerivClauseTys GhcPs
normalizeDerivClauseTys DerivClauseTys GhcPs
rc)