1. 01 Nov, 2015 1 commit
  2. 25 Oct, 2015 1 commit
    • Alan Zimmerman's avatar
      Provide a utility to check API Annotations · 43751b24
      Alan Zimmerman authored
      It is difficult for GHC developers to know if they have broken the API
      Annotations.
      
      This patch provides a utility that can be used as a test to show up
      errors in the API Annotations.
      
      It is based on the current tests for ghc-api/annotations which can parse
      a file using the just-built GHC API, and check that no annotations are
      disconnected from the ParsedSource in the output.
      
      In addition, it should be able to dump the annotations to a file, so a
      new feature developer can check that all changes to the parser do
      provide annotations.
      
      Trac ticket: #10917
      
      Test Plan: ./validate
      
      Reviewers: hvr, thomie, austin, bgamari
      
      Reviewed By: bgamari
      
      Differential Revision: https://phabricator.haskell.org/D1368
      
      GHC Trac Issues: #10917
      43751b24
  3. 02 Aug, 2015 1 commit
    • Alan Zimmerman's avatar
      Replace (SourceText,FastString) with StringLiteral data type · 15dd7007
      Alan Zimmerman authored
      Summary:
      Phab:D907 introduced SourceText for a number of data types, by replacing
      FastString with (SourceText,FastString). Since this has an Outputable
      instance, no warnings are generated when ppr is called on it, but
      unexpected output is generated. See Phab:D1096 for an example of this.
      
      Replace the (SourceText,FastString) tuples with a new data type,
      ```lang=hs
      data StringLiteral = StringLiteral SourceText FastString
      ```
      
      Update haddock submodule accordingly
      
      Test Plan: ./validate
      
      Reviewers: hvr, austin, rwbarton, trofi, bgamari
      
      Reviewed By: trofi, bgamari
      
      Subscribers: thomie, trofi, rwbarton, mpickering
      
      Differential Revision: https://phabricator.haskell.org/D1101
      
      GHC Trac Issues: #10692
      15dd7007
  4. 26 Jun, 2015 1 commit
  5. 18 Jun, 2015 1 commit
    • Alan Zimmerman's avatar
      Parser: commas_tup_tail duplicate SrcSpan on "Missing" value · 72b21c39
      Alan Zimmerman authored
      Summary:
      Parsing
      
          {-# LANGUAGE TupleSections #-}
      
          baz = (1, "hello", 6.5,,) 'a' (Just ())
      
      Results in the following AST fragment
      
          (L tests/examples/Tuple.hs:3:7-25
             (ExplicitTuple
                [ L tests/examples/Tuple.hs:3:8
                    (Present
                       (L tests/examples/Tuple.hs:3:8
                          (HsOverLit
                             (OverLit
                                (HsIntegral [ '1' ] 1)
                                PlaceHolder
                                (HsLit
                                   (HsString
                                      []
                                      {abstract:FastString}))
                                PlaceHolder))))
                , L tests/examples/Tuple.hs:3:11-17
                    (Present
                       (L tests/examples/Tuple.hs:3:11-17
                          (HsLit
                             (HsString
                                [ '"'
                                , 'h'
                                , 'e'
                                , 'l'
                                , 'l'
                                , 'o'
                                , '"'
                                ]
                                {abstract:FastString}))))
                , L tests/examples/Tuple.hs:3:20-22
                    (Present
                       (L tests/examples/Tuple.hs:3:20-22
                          (HsOverLit
                             (OverLit
                                (HsFractional
                                   (FL
                                      [ '6' , '.' , '5' ]
                                      (:% 13 2)))
                                PlaceHolder
                                (HsLit
                                   (HsString
                                      []
                                      {abstract:FastString}))
                                PlaceHolder))))
                , L tests/examples/Tuple.hs:3:24
                    (Missing PlaceHolder)
                , L tests/examples/Tuple.hs:3:24
                    (Missing PlaceHolder)
                ]
      
      The final `Missing PlaceHolder` has a duplicated `SrcSpan`
      
      Test Plan: ./validate
      
      Reviewers: austin, hvr, bgamari
      
      Reviewed By: bgamari
      
      Subscribers: thomie, bgamari, mpickering
      
      Differential Revision: https://phabricator.haskell.org/D995
      
      GHC Trac Issues: #10537
      72b21c39
  6. 01 Jun, 2015 2 commits
    • Alan Zimmerman's avatar
      ApiAnnotations : strings in warnings do not return SourceText · e6191d1c
      Alan Zimmerman authored
      Summary:
      The strings used in a WARNING pragma are captured via
      
          strings :: { Located ([AddAnn],[Located FastString]) }
              : STRING { sL1 $1 ([],[L (gl $1) (getSTRING $1)]) }
          ..
      
      The STRING token has a method getSTRINGs that returns the original
      source text for a string.
      
      A warning of the form
      
          {-# WARNING Logic
                    , mkSolver
                    , mkSimpleSolver
                    , mkSolverForLogic
                    , solverSetParams
                    , solverPush
                    , solverPop
                    , solverReset
                    , solverGetNumScopes
                    , solverAssertCnstr
                    , solverAssertAndTrack
                    , solverCheck
                    , solverCheckAndGetModel
                    , solverGetReasonUnknown
                    "New Z3 API support is still incomplete and fragile: \
                    \you may experience segmentation faults!"
            #-}
      
      returns the concatenated warning string rather than the original source.
      
      This patch now deals with all remaining instances of getSTRING to bring
      in a SourceText for each.
      
      This updates the haddock submodule as well, for the AST change.
      
      Test Plan: ./validate
      
      Reviewers: hvr, austin, goldfire
      
      Reviewed By: austin
      
      Subscribers: bgamari, thomie, mpickering
      
      Differential Revision: https://phabricator.haskell.org/D907
      
      GHC Trac Issues: #10313
      e6191d1c
    • Alan Zimmerman's avatar
      ApiAnnotations : rationalise tests · e00910b0
      Alan Zimmerman authored
      Summary:
      At the moment the API Annotations tests have a driver that has been
      copy/pasted multiple times.
      
      Compile it once, and run it for each test case.
      
      Test Plan: ./validate
      
      Reviewers: hvr, austin
      
      Reviewed By: austin
      
      Subscribers: bgamari, thomie
      
      Differential Revision: https://phabricator.haskell.org/D913
      
      GHC Trac Issues: #10452
      e00910b0
  7. 27 May, 2015 1 commit
    • Alan Zimmerman's avatar
      ApiAnnotations tweaks · c5911479
      Alan Zimmerman authored
      Summary:
      A collection of minor updates for the API Annotations.
      
      1. The annotations for the implicity parameter is disconnected in the
         following
      
          type MPI = ?mpi_secret :: MPISecret
      
      2. In the following, the annotation for one of the commas is disconeected.
      
          mkPoli = mkBila . map ((,,(),,()) <$> P.base <*> P.pos <*> P.form)
      
      3. In the following, the annotation for the parens becomes disconnected
      
          data MaybeDefault v where
              SetTo :: forall v . ( Eq v, Show v ) => !v -> MaybeDefault v
              SetTo4 :: forall v a. (( Eq v, Show v ) => v -> MaybeDefault v
                                                      -> a -> MaybeDefault [a])
      
      Test Plan: ./validate
      
      Reviewers: hvr, austin
      
      Reviewed By: austin
      
      Subscribers: bgamari, thomie, mpickering
      
      Differential Revision: https://phabricator.haskell.org/D901
      
      GHC Trac Issues: #10399
      c5911479
  8. 21 May, 2015 3 commits
  9. 12 May, 2015 2 commits
  10. 11 May, 2015 5 commits
    • Alan Zimmerman's avatar
      ApiAnnotations : PatBind gives wrong SrcSpan for the pattern. · ecc3d6be
      Alan Zimmerman authored
      Summary:
      The production for decl_no_th starts
      
          decl_no_th :: { Located (OrdList (LHsDecl RdrName)) }
                  : sigdecl               { $1 }
      
                  | '!' aexp rhs  {% do { let { e = sLL $1 $> (SectionR (sL1 $1 (HsVar bang_RDR)) $2) };
                                          pat <- checkPattern empty e;
          ...
      
      The e value should be just the pattern, excluding the rhs, but the span
      created includes the rhs.
      
      Test Plan: ./validate
      
      Reviewers: hvr, austin
      
      Reviewed By: austin
      
      Subscribers: bgamari, thomie, mpickering
      
      Differential Revision: https://phabricator.haskell.org/D873
      
      GHC Trac Issues: #10358
      ecc3d6be
    • Alan Zimmerman's avatar
      ApiAnnotations : pquals production adds AnnVbar in the wrong place · fe38195e
      Alan Zimmerman authored
      Summary:
      The Parser.y production for pquals is
      
          pquals :: { Located [[LStmt RdrName (LHsExpr RdrName)]] }
              : squals '|' pquals
                               {% addAnnotation (gl $ last $ unLoc $1) AnnVbar (gl $2) >>
                                  return (sLL $1 $> (reverse (unLoc $1) : unLoc $3)) }
              | squals         { L (getLoc $1) [reverse (unLoc $1)] }
      
      The squals are returned in reverse order, so the AnnVbar should be
      attached to the head of the list, not the last.
      
      Test Plan: ./validate
      
      Reviewers: hvr, austin
      
      Reviewed By: austin
      
      Subscribers: thomie, mpickering
      
      Differential Revision: https://phabricator.haskell.org/D869
      
      GHC Trac Issues: #10357
      fe38195e
    • Alan Zimmerman's avatar
      ApiAnnotations : BooleanFormula construction discards original · 24707d72
      Alan Zimmerman authored
      Summary:
      The MINIMAL pragma is captured in the parser using a BooleanFormula.
      
      The constructors (mkBool,mkAnd,mkOr) are smart and try to minimise the
      boolean formula as it is constructed.
      
      This discards the original information, making round tripping
      impossible.
      
      Note: there is another version which provides a more API Annotations
      friendly version of the MINIMAL pragma, but this requires changes to
      haddock, which will cause problems for 7.10.2.
      
      See https://github.com/alanz/ghc/tree/wip/10287
      
      Test Plan: ./validate
      
      Reviewers: hvr, austin
      
      Reviewed By: austin
      
      Subscribers: bgamari, Fuuzetsu, thomie, mpickering
      
      Differential Revision: https://phabricator.haskell.org/D837
      
      GHC Trac Issues: #10287
      24707d72
    • Alan Zimmerman's avatar
      ApiAnnotations : mkGadtDecl discards annotations for HsFunTy · e4032b19
      Alan Zimmerman authored
      Summary:
      When mkGadtDecl is presented wih a HsFunTy it discards the SrcSpan, thus
      disconnecting any annotations on the HsFunTy.
      
      ```
      mkGadtDecl names (L ls (HsForAllTy imp Nothing qvars cxt tau))
        = return $ mk_gadt_con names
        where
          (details, res_ty)           -- See Note [Sorting out the result type]
            = case tau of
                L _ (HsFunTy (L l (HsRecTy flds)) res_ty)
                                                  -> (RecCon (L l flds), res_ty)
                _other                                    -> (PrefixCon [], tau)
      ...
      ```
      
      This can be triggered by the following
      
      ```
      {-# LANGUAGE GADTs #-}
      module GADTRecords2 (H1(..)) where
      
      -- | h1
      data H1 a b where
        C3 :: (Num a) => { field :: a -- ^ hello docs
                         } -> H1 Int Int
      ```
      
      Test Plan: ./validate
      
      Reviewers: hvr, austin
      
      Reviewed By: austin
      
      Subscribers: bgamari, thomie, mpickering
      
      Differential Revision: https://phabricator.haskell.org/D848
      
      GHC Trac Issues: #10309
      e4032b19
    • Alan Zimmerman's avatar
      Api Annotations: RdrHsSyn.mkAtDefault causes annotations to be disconnected. · 811b72ad
      Alan Zimmerman authored
      Summary:
      The code for mkAtDefault is as follows.
      
          mkATDefault (L loc (TyFamInstDecl { tfid_eqn = L _ e }))
                | TyFamEqn { tfe_tycon = tc, tfe_pats = pats, tfe_rhs = rhs } <- e
                = do { tvs <- checkTyVars (ptext (sLit "default")) equalsDots tc (hswb_cts pats)
                     ; return (L loc (TyFamEqn { tfe_tycon = tc
                                               , tfe_pats = tvs
                                               , tfe_rhs = rhs })) }
      
      An associated type in a class of the form
      
          type FoldableConstraint t x = ()
      
      has an AnnEqual attached to the location in tfid_eqn. Since the location
      is discarded, this annotation is then disconnected from the AST.
      
      Test Plan: ./validate
      
      Reviewers: hvr, austin
      
      Reviewed By: austin
      
      Subscribers: bgamari, thomie, mpickering
      
      Differential Revision: https://phabricator.haskell.org/D842
      
      GHC Trac Issues: #10307
      811b72ad
  11. 08 May, 2015 2 commits
  12. 07 May, 2015 1 commit
    • Alan Zimmerman's avatar
      ApiAnnotations : RdrHsSyn.isFunLhs discards parentheses · 5bde9f7c
      Alan Zimmerman authored
      Summary:
      The RdrHsSyn.isFunLhs function has the following
      
        isFunLhs e = go e []
         where
           go (L loc (HsVar f)) es
                | not (isRdrDataCon f)   = return (Just (L loc f, False, es))
           go (L _ (HsApp f e)) es       = go f (e:es)
           go (L _ (HsPar e))   es@(_:_) = go e es
      
      The treatment of HsPar means that any parentheses around an infix function will be discarded.
      
      e.g.
      
        (f =*= g) sa i = f (toF sa i) =^= g (toG sa i)
      
      will lose the ( before f and the closing one after g
      
      Test Plan: ./validate
      
      Reviewers: hvr, austin
      
      Reviewed By: austin
      
      Subscribers: bgamari, thomie
      
      Differential Revision: https://phabricator.haskell.org/D832
      
      GHC Trac Issues: #10269
      5bde9f7c
  13. 06 May, 2015 5 commits
    • Austin Seipp's avatar
      Revert "API Annotations : add Locations in hsSyn were layout occurs" · 97d320f5
      Austin Seipp authored
      This reverts commit fb54b2c1.
      
      As Alan pointed out, this will make cherry picking a lot harder until
      7.10.2, so lets back it out until after the release.
      97d320f5
    • Austin Seipp's avatar
      Revert "ApiAnnotations : Nested forall loses forall annotation" · f34c0728
      Austin Seipp authored
      This reverts commit 81030ede.
      
      Alan is abandoning this approach in favor of D836.
      f34c0728
    • Alan Zimmerman's avatar
      ApiAnnotations : Nested forall loses forall annotation · 81030ede
      Alan Zimmerman authored
      When parsing
      
          {-# LANGUAGE ScopedTypeVariables #-}
      
          extremumNewton :: forall tag. forall tag1.
                             tag -> tag1 -> Int
          extremumNewton = undefined
      
      The parser attaches an AnnForall to the second forall, which appears as
      a nested HsForAllTy.
      
      Somewhere this nesting is flattened, and the tyvarbndrs are collapsed
      into a single HsForAllTy. In this process the second AnnForAll loses its
      anchor in the AST.
      
      Reviewed By: austin
      
      Differential Revision: https://phabricator.haskell.org/D833
      
      GHC Trac Issues: #10278
      81030ede
    • Alan Zimmerman's avatar
      ApiAnnotations : quoted type variables missing leading quote · 15aafc7f
      Alan Zimmerman authored
      The HsOpTy can be constructed for a promoted type operator, in which case it has the following form
      
              | btype SIMPLEQUOTE qconop type     { sLL $1 $> $ mkHsOpTy $1 $3 $4 }
              | btype SIMPLEQUOTE varop  type     { sLL $1 $> $ mkHsOpTy $1 $3 $4 }
      
      The SIMPLEQUOTE does not get an annotation, so cannot be reproduced via the API Annotations.
      
      Also, in
      
      splice_exp :: { LHsExpr RdrName }
              : TH_ID_SPLICE          { sL1 $1 $ mkHsSpliceE
                                              (sL1 $1 $ HsVar (mkUnqual varName
                                                              (getTH_ID_SPLICE $1))) }
              | '$(' exp ')'          {% ams (sLL $1 $> $ mkHsSpliceE $2) [mo $1,mc $3] }
              | TH_ID_TY_SPLICE       { sL1 $1 $ mkHsSpliceTE
                                              (sL1 $1 $ HsVar (mkUnqual varName
                                                           (getTH_ID_TY_SPLICE $1))) }
              | '$$(' exp ')'         {% ams (sLL $1 $> $ mkHsSpliceTE $2) [mo $1,mc $3] }
      
      the TH_ID_SPLICE and TH_ID_TY_SPLICE positions are lost.
      
      Reviewed By: austin
      
      Differential Revision: https://phabricator.haskell.org/D825
      
      GHC Trac Issues: #10268
      15aafc7f
    • Alan Zimmerman's avatar
      API Annotations : add Locations in hsSyn were layout occurs · fb54b2c1
      Alan Zimmerman authored
      At the moment ghc-exactprint, which uses the GHC API Annotations to
      provide a framework for roundtripping Haskell source code with optional
      AST edits, has to implement a horrible workaround to manage the points
      where layout needs to be captured.
      
      These are
      
          MatchGroup
          HsDo
          HsCmdDo
          HsLet
          LetStmt
          HsCmdLet
          GRHSs
      
      To provide a more natural representation, the contents subject to layout
      rules need to be wrapped in a SrcSpan.
      
      This commit does this.
      
      Trac ticket #10250
      
      Reviewed By: austin
      
      Differential Revision: https://phabricator.haskell.org/D815
      
      GHC Trac Issues: #10250
      fb54b2c1
  14. 14 Apr, 2015 5 commits
  15. 07 Apr, 2015 2 commits
  16. 23 Feb, 2015 1 commit
    • thomie's avatar
      Declare some Makefile targets to be PHONY · a0ef626e
      thomie authored
      Summary:
      Given:
        a Makefile with a non-PHONY target called `target`
      If:
        after running `make target`, a file exists with the same name as `target`
        (it was either already there, or it was created by running `make target`)
      And:
        `target` has no dependencies, such as `clean`, that modify or delete that
        file
      Then:
        subsequent invocations of `make target` will not have any effect.
      
      Solution: make `target` PHONY.
      
      BAD:
        ```
        foo:
                ...
                ./foo
        ```
      
      BETTER:
        ```
        foo:
                ...
                ./foo
        .PHONY: foo
        ```
      
      Reviewers: austin
      
      Reviewed By: austin
      
      Subscribers: thomie
      
      Differential Revision: https://phabricator.haskell.org/D670
      a0ef626e
  17. 19 Jan, 2015 1 commit
    • Alan Zimmerman's avatar
      API Annotations documentation update, parsing issue, add example test · 851ed721
      Alan Zimmerman authored
      Summary:
      Add a reference note to each AnnKeywordId haddock comment so GHC
      developers will have an idea why they are there.
      
      Add a new test to ghc-api/annotations to serve as a template for other
      GHC developers when they need to update the parser. It provides output
      which checks that each SrcSpan that an annotation is attached to
      actually appears in the `ParsedSource`, and lists the individual
      annotations. The idea is that a developer writes a version of this
      which parses a sample file using whatever syntax is changed in
      Parser.y, and can then check that all the annotations come through.
      
      Depends on D538
      
      Test Plan: ./validate
      
      Reviewers: simonpj, hvr, austin
      
      Reviewed By: austin
      
      Subscribers: thomie, jstolarek
      
      Differential Revision: https://phabricator.haskell.org/D620
      851ed721
  18. 16 Jan, 2015 1 commit
    • Alan Zimmerman's avatar
      API Annotations tweaks. · 11881ec6
      Alan Zimmerman authored
      Summary:
      HsTyLit now has SourceText
      
      Update documentation of HsSyn to reflect which annotations are attached to which element.
      
      Ensure that the parser always keeps HsSCC and HsTickPragma values, to
      be ignored in the desugar phase if not needed
      
      Bringing in SourceText for pragmas
      
      Add Location in NPlusKPat
      
      Add Location in FunDep
      
      Make RecCon payload Located
      
      Explicitly add AnnVal to RdrName where it is compound
      
      Add Location in IPBind
      
      Add Location to name in IEThingAbs
      
      Add Maybe (Located id,Bool) to Match to track fun_id,infix
        This includes converting Match into a record and adding a note about why
        the fun_id needs to be replicated in the Match.
      
      Add Location in KindedTyVar
      
      Sort out semi-colons for parsing
      
        - import statements
        - stmts
        - decls
        - decls_cls
        - decls_inst
      
      This updates the haddock submodule.
      
      Test Plan: ./validate
      
      Reviewers: hvr, austin, goldfire, simonpj
      
      Reviewed By: simonpj
      
      Subscribers: thomie, carter
      
      Differential Revision: https://phabricator.haskell.org/D538
      11881ec6
  19. 03 Dec, 2014 1 commit
  20. 30 Nov, 2014 1 commit
  21. 24 Nov, 2014 1 commit
  22. 21 Nov, 2014 1 commit
    • Alan Zimmerman's avatar
      Add API Annotations · 803fc5db
      Alan Zimmerman authored
      Summary:
      The final design and discussion is captured at
      https://ghc.haskell.org/trac/ghc/wiki/GhcAstAnnotations
      
      This is a proof of concept implementation of a completely
      separate annotation structure, populated in the parser,and tied to the
      AST by means of a virtual "node-key" comprising the surrounding
      SrcSpan and a value derived from the specific constructor used for the
      node.
      
      The key parts of the design are the following.
      
      == The Annotations ==
      
      In `hsSyn/ApiAnnotation.hs`
      
      ```lang=haskell
      type ApiAnns = (Map.Map ApiAnnKey SrcSpan, Map.Map SrcSpan [Located Token])
      
      type ApiAnnKey = (SrcSpan,AnnKeywordId)
      
      -- ---------------------------------------------------------------------
      
      -- | Retrieve an annotation based on the @SrcSpan@ of the annotated AST
      -- element, and the known type of the annotation.
      getAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> Maybe SrcSpan
      getAnnotation (anns,_) span ann = Map.lookup (span,ann) anns
      
      -- |Retrieve the comments allocated to the current @SrcSpan@
      getAnnotationComments :: ApiAnns -> SrcSpan -> [Located Token]
      getAnnotationComments (_,anns) span =
        case Map.lookup span anns of
          Just cs -> cs
          Nothing -> []
      
      -- | Note: in general the names of these are taken from the
      -- corresponding token, unless otherwise noted
      data AnnKeywordId
               = AnnAs
               | AnnBang
               | AnnClass
               | AnnClose -- ^ } or ] or ) or #) etc
               | AnnComma
               | AnnDarrow
               | AnnData
               | AnnDcolon
               ....
      ```
      
      == Capturing in the lexer/parser ==
      
      The annotations are captured in the lexer / parser by extending PState to include a field
      
      In `parser/Lexer.x`
      
      ```lang=haskell
      data PState = PState {
              ....
              annotations :: [(ApiAnnKey,SrcSpan)]
              -- Annotations giving the locations of 'noise' tokens in the
              -- source, so that users of the GHC API can do source to
              -- source conversions.
           }
      ```
      
      The lexer exposes a helper function to add an annotation
      
      ```lang=haskell
      addAnnotation :: SrcSpan -> Ann -> SrcSpan -> P ()
      addAnnotation l a v = P $ \s -> POk s {
        annotations = ((AK l a), v) : annotations s
        } ()
      
      ```
      
      The parser also has some helper functions of the form
      
      ```lang=haskell
      type MaybeAnn = Maybe (SrcSpan -> P ())
      
      gl = getLoc
      gj x = Just (gl x)
      
      ams :: Located a -> [MaybeAnn] -> P (Located a)
      ams a@(L l _) bs = (mapM_ (\a -> a l) $ catMaybes bs) >> return a
      ```
      
      This allows annotations to be captured in the parser by means of
      
      ```
      ctypedoc :: { LHsType RdrName }
              : 'forall' tv_bndrs '.' ctypedoc {% hintExplicitForall (getLoc $1) >>
                                                  ams (LL $ mkExplicitHsForAllTy $2 (noLoc []) $4)
                                                      [mj AnnForall $1,mj AnnDot $3] }
              | context '=>' ctypedoc         {% ams (LL $ mkQualifiedHsForAllTy   $1 $3)
                                                     [mj AnnDarrow $2] }
              | ipvar '::' type               {% ams (LL (HsIParamTy (unLoc $1) $3))
                                                     [mj AnnDcolon $2] }
              | typedoc                       { $1 }
      ```
      
      == Parse result ==
      
      ```lang-haskell
      data HsParsedModule = HsParsedModule {
          hpm_module    :: Located (HsModule RdrName),
          hpm_src_files :: [FilePath],
             -- ^ extra source files (e.g. from #includes).  The lexer collects
             -- these from '# <file> <line>' pragmas, which the C preprocessor
             -- leaves behind.  These files and their timestamps are stored in
             -- the .hi file, so that we can force recompilation if any of
             -- them change (#3589)
          hpm_annotations :: ApiAnns
        }
      
      -- | The result of successful parsing.
      data ParsedModule =
        ParsedModule { pm_mod_summary   :: ModSummary
                     , pm_parsed_source :: ParsedSource
                     , pm_extra_src_files :: [FilePath]
                     , pm_annotations :: ApiAnns }
      ```
      
      This diff depends on D426
      
      Test Plan: sh ./validate
      
      Reviewers: austin, simonpj, Mikolaj
      
      Reviewed By: simonpj, Mikolaj
      
      Subscribers: Mikolaj, goldfire, thomie, carter
      
      Differential Revision: https://phabricator.haskell.org/D438
      
      GHC Trac Issues: #9628
      803fc5db