1. 05 Aug, 2021 1 commit
  2. 17 Jun, 2021 1 commit
  3. 20 May, 2021 1 commit
  4. 13 May, 2021 1 commit
  5. 27 Apr, 2021 1 commit
    • Ryan Scott's avatar
      Pretty-print HsArgPar applications correctly (#19737) · dd121fa1
      Ryan Scott authored
      Previously, the `Outputable` instance for `HsArg` was being used to
      pretty-print each `HsArgPar` in a list of `HsArg`s individually, which
      simply doesn't work. In lieu of the `Outputable` instance, we now use
      a dedicated `pprHsArgsApp` function to print a list of `HsArg`s as a single
      unit. I have also added documentation to the `Outputable` instance for `HsArg`
      to more clearly signpost that it is only suitable for debug pretty-printing.
      
      Fixes #19737.
      dd121fa1
  6. 19 Apr, 2021 1 commit
    • Alan Zimmerman's avatar
      EPA: cleanups after the merge · 0619fb0f
      Alan Zimmerman authored
      Remove EpaAnn type synonym, rename EpaAnn' to EpaAnn.
      Closes #19705
      
      Updates haddock submodule
      
      --
      
      Change
        data EpaAnchor = AR RealSrcSpan
                       | AD DeltaPos
      
      To instead be
        data EpaAnchor = AnchorReal RealSrcSpan
                       | AnchorDelta DeltaPos
      
      Closes #19699
      
      --
      
      Change
        data DeltaPos =
          DP
            { deltaLine   :: !Int,
              deltaColumn :: !Int
            }
      
      To instead be
        data DeltaPos
          = SameLine { deltaColumn :: !Int }
          | DifferentLine { deltaLine :: !Int, startColumn :: !Int }
      
      Closes #19698
      
      --
      
      Also some clean-ups of unused parts of check-exact.
      0619fb0f
  7. 31 Mar, 2021 2 commits
  8. 25 Mar, 2021 1 commit
    • Hécate Moonlight's avatar
      Add compiler linting to CI · 0029df2b
      Hécate Moonlight authored
      This commit adds the `lint:compiler` Hadrian target to the CI runner.
      It does also fixes hints in the compiler/ and libraries/base/ codebases.
      0029df2b
  9. 20 Mar, 2021 1 commit
  10. 01 Mar, 2021 1 commit
  11. 24 Jan, 2021 2 commits
    • John Ericson's avatar
      Track the dependencies of `GHC.Hs.Expr.Types` · 8ec6d62a
      John Ericson authored
      Thery is still, in my view, far too numerous, but I believe this won't
      be too hard to improve upon. At the very lease, we can always add more
      extension points!
      8ec6d62a
    • John Ericson's avatar
      Separate AST from GhcPass (#18936) · 81f06655
      John Ericson authored
      ```-------------
      What:
      
      There are two splits.
      
      The first spit is:
      
       - `Language.Haskell.Syntax.Extension`
       - `GHC.Hs.Extension`
      
      where the former now just contains helpers like `NoExtCon` and all the
      families, and the latter is everything having to do with `GhcPass`.
      
      The second split is:
      
       - `Language.Haskell.Syntax.<mod>`
       - `GHC.Hs.<mod>`
      
      Where the former contains all the data definitions, and the few helpers
      that don't use `GhcPass`, and the latter contains everything else. The
      second modules also reexport the former.
      ```
      
      -------------
      Why:
      
      See the issue for more details, but in short answer is we're trying to
      grasp at the modularity TTG is supposed to offer, after a long time of
      mainly just getting the safety benefits of more complete pattern
      matching on the AST.
      
      Now, we have an AST datatype which, without `GhcPass` is decently
      stripped of GHC-specific concerns. Whereas before, not was it
      GHC-specific, it was aware of all the GHC phases despite the
      parameterization, with the instances and parametric data structure
      side-by-side.
      
      For what it's worth there are also some smaller, imminent benefits:
      
      - The latter change also splits a strongly connected component in two,
        since none of the `Language.Haskell.Syntax.*` modules import the older
        ones.
      
      - A few TTG violations (Using GhcPass directly in the AST) in `Expr` are
        now more explicitly accounted for with new type families to provide the
        necessary indirection.
      
      -----------------
      Future work:
      
      - I don't see why all the type families should live in
        `Language.Haskell.Syntax.Extension`. That seems anti-modular for
        little benefit. All the ones used just once can be moved next to the
        AST type they serve as an extension point for.
      
      - Decide what to do with the `Outputable` instances. Some of these are
        no orphans because they referred to `GhcPass`, and had to be moved. I
        think the types could be generalized so they don't refer to `GhcPass`
        and therefore can be moved back, but having gotten flak for increasing
        the size and complexity types when generalizing before, I did *not*
        want to do this.
      
      - We should triage the remaining contents of `GHC.Hs.<mod>`. The
        renaming helpers are somewhat odd for needing `GhcPass`. We might
        consider if they are a) in fact only needed by one phase b) can be
        generalized to be non-GhcPass-specific (e.g. take a callback rather
        than GADT-match with `IsPass`) and then they can live in
        `Language.Haskell.Syntax.<mod>`.
      
      For more details, see
      https://gitlab.haskell.org/ghc/ghc/-/wikis/implementing-trees-that-grow
      
      Bumps Haddock submodule
      81f06655
  12. 14 Dec, 2020 1 commit
  13. 06 Nov, 2020 1 commit
    • Ryan Scott's avatar
      Replace HsImplicitBndrs with HsOuterTyVarBndrs · e07e383a
      Ryan Scott authored
      This refactors the GHC AST to remove `HsImplicitBndrs` and replace it with
      `HsOuterTyVarBndrs`, a type which records whether the outermost quantification
      in a type is explicit (i.e., with an outermost, invisible `forall`) or
      implicit. As a result of this refactoring, it is now evident in the AST where
      the `forall`-or-nothing rule applies: it's all the places that use
      `HsOuterTyVarBndrs`. See the revamped `Note [forall-or-nothing rule]` in
      `GHC.Hs.Type` (previously in `GHC.Rename.HsType`).
      
      Moreover, the places where `ScopedTypeVariables` brings lexically scoped type
      variables into scope are a subset of the places that adhere to the
      `forall`-or-nothing rule, so this also makes places that interact with
      `ScopedTypeVariables` easier to find. See the revamped
      `Note [Lexically scoped type variables]` in `GHC.Hs.Type` (previously in
      `GHC.Tc.Gen.Sig`).
      
      `HsOuterTyVarBndrs` are used in type signatures (see `HsOuterSigTyVarBndrs`)
      and type family equations (see `HsOuterFamEqnTyVarBndrs`). The main difference
      between the former and the latter is that the former cares about specificity
      but the latter does not.
      
      There are a number of knock-on consequences:
      
      * There is now a dedicated `HsSigType` type, which is the combination of
        `HsOuterSigTyVarBndrs` and `HsType`. `LHsSigType` is now an alias for an
        `XRec` of `HsSigType`.
      * Working out the details led us to a substantial refactoring of
        the handling of explicit (user-written) and implicit type-variable
        bindings in `GHC.Tc.Gen.HsType`.
      
        Instead of a confusing family of higher order functions, we now
        have a local data type, `SkolemInfo`, that controls how these
        binders are kind-checked.
      
        It remains very fiddly, not fully satisfying. But it's better
        than it was.
      
      Fixes #16762
      
      . Bumps the Haddock submodule.
      Co-authored-by: Simon Peyton Jones's avatarSimon Peyton Jones <simonpj@microsoft.com>
      Co-authored-by: Richard Eisenberg's avatarRichard Eisenberg <rae@richarde.dev>
      Co-authored-by: Zubin's avatarZubin Duggal <zubin@cmi.ac.in>
      e07e383a
  14. 30 Oct, 2020 1 commit
    • Ryan Scott's avatar
      Split HsConDecl{H98,GADT}Details · 31fcb55f
      Ryan Scott authored
      Haskell98 and GADT constructors both use `HsConDeclDetails`, which includes
      `InfixCon`. But `InfixCon` is never used for GADT constructors, which results
      in an awkward unrepresentable state. This removes the unrepresentable state by:
      
      * Renaming the existing `HsConDeclDetails` synonym to `HsConDeclH98Details`,
        which emphasizes the fact that it is now only used for Haskell98-style data
        constructors, and
      * Creating a new `HsConDeclGADTDetails` data type with `PrefixConGADT` and
        `RecConGADT` constructors that closely resemble `PrefixCon` and `InfixCon`
        in `HsConDeclH98Details`. The key difference is that `HsConDeclGADTDetails`
        lacks any way to represent infix constructors.
      
      The rest of the patch is refactoring to accommodate the new structure of
      `HsConDecl{H98,GADT}Details`. Some highlights:
      
      * The `getConArgs` and `hsConDeclArgTys` functions have been removed, as
        there is no way to implement these functions uniformly for all
        `ConDecl`s. For the most part, their previous call sites now
        pattern match on the `ConDecl`s directly and do different things for
        `ConDeclH98`s and `ConDeclGADT`s.
      
        I did introduce one new function to make the transition easier:
        `getRecConArgs_maybe`, which extracts the arguments from a `RecCon(GADT)`.
        This is still possible since `RecCon(GADT)`s still use the same representation
        in both `HsConDeclH98Details` and `HsConDeclGADTDetails`, and since the
        pattern that `getRecConArgs_maybe` implements is used in several places,
        I thought it worthwhile to factor it out into its own function.
      * Previously, the `con_args` fields in `ConDeclH98` and `ConDeclGADT` were
        both of type `HsConDeclDetails`. Now, the former is of type
        `HsConDeclH98Details`, and the latter is of type `HsConDeclGADTDetails`,
        which are distinct types. As a result, I had to rename the `con_args` field
        in `ConDeclGADT` to `con_g_args` to make it typecheck.
      
        A consequence of all this is that the `con_args` field is now partial, so
        using `con_args` as a top-level field selector is dangerous. (Indeed, Haddock
        was using `con_args` at the top-level, which caused it to crash at runtime
        before I noticed what was wrong!) I decided to add a disclaimer in the 9.2.1
        release notes to advertise this pitfall.
      
      Fixes #18844. Bumps the `haddock` submodule.
      31fcb55f
  15. 29 Oct, 2020 1 commit
    • Sylvain Henry's avatar
      Split GHC.Driver.Types · 0e9f6def
      Sylvain Henry authored
      I was working on making DynFlags stateless (#17957), especially by
      storing loaded plugins into HscEnv instead of DynFlags. It turned out to
      be complicated because HscEnv is in GHC.Driver.Types but LoadedPlugin
      isn't: it is in GHC.Driver.Plugins which depends on GHC.Driver.Types. I
      didn't feel like introducing yet another hs-boot file to break the loop.
      
      Additionally I remember that while we introduced the module hierarchy
      (#13009) we talked about splitting GHC.Driver.Types because it contained
      various unrelated types and functions, but we never executed. I didn't
      feel like making GHC.Driver.Types bigger with more unrelated Plugins
      related types, so finally I bit the bullet and split GHC.Driver.Types.
      
      As a consequence this patch moves a lot of things. I've tried to put
      them into appropriate modules but nothing is set in stone.
      
      Several other things moved to avoid loops.
      
      * Removed Binary instances from GHC.Utils.Binary for random compiler
        things
      * Moved Typeable Binary instances into GHC.Utils.Binary.Typeable: they
        import a lot of things that users of GHC.Utils.Binary don't want to
        depend on.
      * put everything related to Units/Modules under GHC.Unit:
        GHC.Unit.Finder, GHC.Unit.Module.{ModGuts,ModIface,Deps,etc.}
      * Created several modules under GHC.Types: GHC.Types.Fixity, SourceText,
        etc.
      * Split GHC.Utils.Error (into GHC.Types.Error)
      * Finally removed GHC.Driver.Types
      
      Note that this patch doesn't put loaded plugins into HscEnv. It's left
      for another patch.
      
      Bump haddock submodule
      0e9f6def
  16. 10 Oct, 2020 1 commit
  17. 29 Sep, 2020 1 commit
  18. 27 Sep, 2020 1 commit
  19. 15 Sep, 2020 1 commit
    • Ryan Scott's avatar
      Introduce and use DerivClauseTys (#18662) · 4283feaa
      Ryan Scott authored
      This switches `deriv_clause_tys` so that instead of using a list of
      `LHsSigType`s to represent the types in a `deriving` clause, it now
      uses a sum type. `DctSingle` represents a `deriving` clause with no
      enclosing parentheses, while `DctMulti` represents a clause with
      enclosing parentheses. This makes pretty-printing easier and avoids
      confusion between `HsParTy` and the enclosing parentheses in
      `deriving` clauses, which are different semantically.
      
      Fixes #18662.
      4283feaa
  20. 25 Aug, 2020 1 commit
    • Simon Peyton Jones's avatar
      Use LIdP rather than (XRec p (IdP p)) · fb77207a
      Simon Peyton Jones authored
      This patch mainly just replaces use of
          XRec p (IdP p)
      with
          LIdP p
      
      One slightly more significant change is to parameterise
      HsPatSynDetails over the pass rather than the argument type,
      so that it's uniform with HsConDeclDetails and HsConPatDetails.
      
      I also got rid of the dead code GHC.Hs.type.conDetailsArgs
      
      But this is all just minor refactoring. No change in functionality.
      fb77207a
  21. 12 Aug, 2020 1 commit
    • Sylvain Henry's avatar
      DynFlags: disentangle Outputable · accbc242
      Sylvain Henry authored
      - put panic related functions into GHC.Utils.Panic
      - put trace related functions using DynFlags in GHC.Driver.Ppr
      
      One step closer making Outputable fully independent of DynFlags.
      
      Bump haddock submodule
      accbc242
  22. 02 Aug, 2020 1 commit
    • Ryan Scott's avatar
      Remove ConDeclGADTPrefixPs · 22641742
      Ryan Scott authored
      This removes the `ConDeclGADTPrefixPs` per the discussion in #18517.
      Most of this patch simply removes code, although the code in the
      `rnConDecl` case for `ConDeclGADTPrefixPs` had to be moved around a
      bit:
      
      * The nested `forall`s check now lives in the `rnConDecl` case for
        `ConDeclGADT`.
      * The `LinearTypes`-specific code that used to live in the
        `rnConDecl` case for `ConDeclGADTPrefixPs` now lives in
        `GHC.Parser.PostProcess.mkGadtDecl`, which is now monadic so that
        it can check if `-XLinearTypes` is enabled.
      
      Fixes #18157.
      22641742
  23. 25 Jul, 2020 1 commit
  24. 21 Jul, 2020 1 commit
    • Vladislav Zavialov's avatar
      Accumulate Haddock comments in P (#17544, #17561, #8944) · 19e80b9a
      Vladislav Zavialov authored
      Haddock comments are, first and foremost, comments. It's very annoying
      to incorporate them into the grammar. We can take advantage of an
      important property: adding a Haddock comment does not change the parse
      tree in any way other than wrapping some nodes in HsDocTy and the like
      (and if it does, that's a bug).
      
      This patch implements the following:
      
      * Accumulate Haddock comments with their locations in the P monad.
        This is handled in the lexer.
      
      * After parsing, do a pass over the AST to associate Haddock comments
        with AST nodes using location info.
      
      * Report the leftover comments to the user as a warning (-Winvalid-haddock).
      19e80b9a
  25. 28 Jun, 2020 1 commit
  26. 25 Jun, 2020 1 commit
    • Takenobu Tani's avatar
      Clean up haddock hyperlinks of GHC.* (part1) · c7dd6da7
      Takenobu Tani authored
      This updates haddock comments only.
      
      This patch focuses to update for hyperlinks in GHC API's haddock comments,
      because broken links especially discourage newcomers.
      
      This includes the following hierarchies:
        - GHC.Hs.*
        - GHC.Core.*
        - GHC.Stg.*
        - GHC.Cmm.*
        - GHC.Types.*
        - GHC.Data.*
        - GHC.Builtin.*
        - GHC.Parser.*
        - GHC.Driver.*
        - GHC top
      c7dd6da7
  27. 17 Jun, 2020 1 commit
    • Krzysztof Gogolewski's avatar
      Linear types (#15981) · 40fa237e
      Krzysztof Gogolewski authored
      This is the first step towards implementation of the linear types proposal
      (https://github.com/ghc-proposals/ghc-proposals/pull/111).
      
      It features
      
      * A language extension -XLinearTypes
      * Syntax for linear functions in the surface language
      * Linearity checking in Core Lint, enabled with -dlinear-core-lint
      * Core-to-core passes are mostly compatible with linearity
      * Fields in a data type can be linear or unrestricted; linear fields
        have multiplicity-polymorphic constructors.
        If -XLinearTypes is disabled, the GADT syntax defaults to linear fields
      
      The following items are not yet supported:
      
      * a # m -> b syntax (only prefix FUN is supported for now)
      * Full multiplicity inference (multiplicities are really only checked)
      * Decent linearity error messages
      * Linear let, where, and case expressions in the surface language
        (each of these currently introduce the unrestricted variant)
      * Multiplicity-parametric fields
      * Syntax for annotating lambda-bound or let-bound with a multiplicity
      * S...
      40fa237e
  28. 13 Jun, 2020 1 commit
    • Ryan Scott's avatar
      Use HsForAllTelescope to avoid inferred, visible foralls · a31218f7
      Ryan Scott authored
      Currently, `HsForAllTy` permits the combination of `ForallVis` and
      `Inferred`, but you can't actually typecheck code that uses it
      (e.g., `forall {a} ->`). This patch refactors `HsForAllTy` to use a
      new `HsForAllTelescope` data type that makes a type-level distinction
      between visible and invisible `forall`s such that visible `forall`s
      do not track `Specificity`. That part of the patch is actually quite
      small; the rest is simply changing consumers of `HsType` to
      accommodate this new type.
      
      Fixes #18235. Bumps the `haddock` submodule.
      a31218f7
  29. 09 Jun, 2020 1 commit
    • Ryan Scott's avatar
      Make GADT constructors adhere to the forall-or-nothing rule properly · 72c7fe9a
      Ryan Scott authored
      Issue #18191 revealed that the types of GADT constructors don't quite
      adhere to the `forall`-or-nothing rule. This patch serves to clean up
      this sad state of affairs somewhat. The main change is not in the
      code itself, but in the documentation, as this patch introduces two
      sections to the GHC User's Guide:
      
      * A "Formal syntax for GADTs" section that presents a BNF-style
        grammar for what is and isn't allowed in GADT constructor types.
        This mostly exists to codify GHC's existing behavior, but it also
        imposes a new restriction that addresses #18191: the outermost
        `forall` and/or context in a GADT constructor is not allowed to be
        surrounded by parentheses. Doing so would make these
        `forall`s/contexts nested, and GADTs do not support nested
        `forall`s/contexts at present.
      
      * A "`forall`-or-nothing rule" section that describes exactly what
        the `forall`-or-nothing rule is all about. Surprisingly, there was
        no mention of this anywhere in the User's Guide up until now!
      
      To adhere the new specification in the "Formal syntax for GADTs"
      section of the User's Guide, the following code changes were made:
      
      * A new function, `GHC.Hs.Type.splitLHsGADTPrefixTy`, was introduced.
        This is very much like `splitLHsSigmaTy`, except that it avoids
        splitting apart any parentheses, which can be syntactically
        significant for GADT types. See
        `Note [No nested foralls or contexts in GADT constructors]` in
        `GHC.Hs.Type`.
      
      * `ConDeclGADTPrefixPs`, an extension constructor for `XConDecl`, was
        introduced so that `GHC.Parser.PostProcess.mkGadtDecl` can return
        it when given a prefix GADT constructor. Unlike `ConDeclGADT`,
        `ConDeclGADTPrefixPs` does not split the GADT type into its argument
        and result types, as this cannot be done until after the type is
        renamed (see `Note [GADT abstract syntax]` in `GHC.Hs.Decls` for why
        this is the case).
      
      * `GHC.Renamer.Module.rnConDecl` now has an additional case for
        `ConDeclGADTPrefixPs` that (1) splits apart the full `LHsType` into
        its `forall`s, context, argument types, and result type, and
        (2) checks for nested `forall`s/contexts. Step (2) used to be
        performed the typechecker (in `GHC.Tc.TyCl.badDataConTyCon`) rather
        than the renamer, but now the relevant code from the typechecker
        can simply be deleted.
      
        One nice side effect of this change is that we are able to give a
        more accurate error message for GADT constructors that use visible
        dependent quantification (e.g., `MkFoo :: forall a -> a -> Foo a`),
        which improves the stderr in the `T16326_Fail6` test case.
      
      Fixes #18191. Bumps the Haddock submodule.
      72c7fe9a
  30. 05 Jun, 2020 1 commit
    • Ryan Scott's avatar
      Simplify bindLHsTyVarBndrs and bindHsQTyVars · 2dff8141
      Ryan Scott authored
      Both `bindLHsTyVarBndrs` and `bindHsQTyVars` take two separate
      `Maybe` arguments, which I find terribly confusing. Thankfully, it's
      possible to remove one `Maybe` argument from each of these functions,
      which this patch accomplishes:
      
      * `bindHsQTyVars` takes a `Maybe SDoc` argument, which is `Just` if
        GHC should warn about any of the quantified type variables going
        unused. However, every call site uses `Nothing` in practice. This
        makes sense, since it doesn't really make sense to warn about
        unused type variables bound by an `LHsQTyVars`. For instance, you
        wouldn't warn about the `a` in `data Proxy a = Proxy` going unused.
      
        As a result, I simply remove this `Maybe SDoc` argument altogether.
      * `bindLHsTyVarBndrs` also takes a `Maybe SDoc` argument for the same
        reasons that `bindHsQTyVars` took one. To make things more
        confusing, however, `bindLHsTyVarBndrs` also takes a separate
        `HsDocContext` argument, which is pretty-printed (to an `SDoc`) in
        warnings and error messages.
      
        In practice, the `Maybe SDoc` and the `HsDocContext` often contain
        the same text. See the call sites for `bindLHsTyVarBndrs` in
        `rnFamInstEqn` and `rnConDecl`, for instance. There are only a
        handful of call sites where the text differs between the
        `Maybe SDoc` and `HsDocContext` arguments:
      
        * In `rnHsRuleDecl`, where the `Maybe SDoc` says "`In the rule`"
          and the `HsDocContext` says "`In the transformation rule`".
        * In `rnHsTyKi`/`rn_ty`, where the `Maybe SDoc` says
          "`In the type`" but the `HsDocContext` is inhereted from the
          surrounding context (e.g., if `rnHsTyKi` were called on a
          top-level type signature, the `HsDocContext` would be
          "`In the type signature`" instead)
      
        In both cases, warnings/error messages arguably _improve_ by
        unifying making the `Maybe SDoc`'s text match that of the
        `HsDocContext`. As a result, I decided to remove the `Maybe SDoc`
        argument to `bindLHsTyVarBndrs` entirely and simply reuse the text
        from the `HsDocContext`. (I decided to change the phrase
        "transformation rule" to "rewrite rule" while I was in the area.)
      
        The `Maybe SDoc` argument has one other purpose: signaling when to
        emit "`Unused quantified type variable`" warnings. To recover this
        functionality, I replaced the `Maybe SDoc` argument with a
        boolean-like `WarnUnusedForalls` argument. The only
        `bindLHsTyVarBndrs` call site that chooses _not_ to emit these
        warnings in `bindHsQTyVars`.
      2dff8141
  31. 24 May, 2020 1 commit
  32. 21 May, 2020 1 commit
    • Gert-Jan Bottu's avatar
      Explicit Specificity · a9311cd5
      Gert-Jan Bottu authored
      Implementation for Ticket #16393.
      Explicit specificity allows users to manually create inferred type variables,
      by marking them with braces.
      This way, the user determines which variables can be instantiated through
      visible type application.
      
      The additional syntax is included in the parser, allowing users to write
      braces in type variable binders (type signatures, data constructors etc).
      This information is passed along through the renamer and verified in the
      type checker.
      The AST for type variable binders, data constructors, pattern synonyms,
      partial signatures and Template Haskell has been updated to include the
      specificity of type variables.
      
      Minor notes:
      - Bumps haddock submodule
      - Disables pattern match checking in GHC.Iface.Type with GHC 8.8
      a9311cd5
  33. 14 May, 2020 1 commit
    • Ryan Scott's avatar
      Factor out HsPatSigType for pat sigs/RULE term sigs (#16762) · 102cfd67
      Ryan Scott authored
      This implements chunks (2) and (3) of
      #16762 (comment 270170). Namely,
      it introduces a dedicated `HsPatSigType` AST type, which represents
      the types that can appear in pattern signatures and term-level `RULE`
      binders. Previously, these were represented with `LHsSigWcType`.
      Although `LHsSigWcType` is isomorphic to `HsPatSigType`, the intended
      semantics of the two types are slightly different, as evidenced by
      the fact that they have different code paths in the renamer and
      typechecker.
      
      See also the new `Note [Pattern signature binders and scoping]` in
      `GHC.Hs.Types`.
      102cfd67
  34. 26 Apr, 2020 1 commit
  35. 18 Apr, 2020 1 commit
    • Sylvain Henry's avatar
      Modules (#13009) · 15312bbb
      Sylvain Henry authored
      * SysTools
      * Parser
      * GHC.Builtin
      * GHC.Iface.Recomp
      * Settings
      
      Update Haddock submodule
      
      Metric Decrease:
          Naperian
          parsing001
      15312bbb
  36. 07 Apr, 2020 2 commits
    • Ryan Scott's avatar
      Make NoExtCon fields strict · 04b6cf94
      Ryan Scott authored
      This changes every unused TTG extension constructor to be strict in
      its field so that the pattern-match coverage checker is smart enough
      any such constructors are unreachable in pattern matches. This lets
      us remove nearly every use of `noExtCon` in the GHC API. The only
      ones we cannot remove are ones underneath uses of `ghcPass`, but that
      is only because GHC 8.8's and 8.10's coverage checkers weren't smart
      enough to perform this kind of reasoning. GHC HEAD's coverage
      checker, on the other hand, _is_ smart enough, so we guard these uses
      of `noExtCon` with CPP for now.
      
      Bumps the `haddock` submodule.
      
      Fixes #17992.
      04b6cf94
    • Sylvain Henry's avatar
      Modules: type-checker (#13009) · 255418da
      Sylvain Henry authored
      Update Haddock submodule
      255418da
  37. 29 Mar, 2020 1 commit