1. 07 Jun, 2018 13 commits
    • Ryan Scott's avatar
      Fix #15243 by fixing incorrect uses of NotPromoted · 569c16a7
      Ryan Scott authored
      In `Convert`, we were incorrectly using `NotPromoted` to
      denote type constructors that were actually intended to be promoted,
      resulting in poor `-ddump-splices` output (as seen in #15243).
      Easily fixed.
      
      Test Plan: make test TEST=T15243
      
      Reviewers: bgamari, goldfire
      
      Reviewed By: bgamari
      
      Subscribers: rwbarton, thomie, carter
      
      GHC Trac Issues: #15243
      
      Differential Revision: https://phabricator.haskell.org/D4809
      569c16a7
    • Ben Gamari's avatar
      testsuite: Add test for #15232 · 5026840f
      Ben Gamari authored
      Subscribers: rwbarton, thomie, carter
      
      GHC Trac Issues: #15232
      
      Differential Revision: https://phabricator.haskell.org/D4807
      5026840f
    • Alec Theriault's avatar
      Move 'HsBangTy' out in constructor arguments · 0361fc03
      Alec Theriault authored
      When run with -haddock, a constructor argument can have both a a
      strictness/unpackedness annotation and a docstring. The parser binds
      'HsBangTy' more tightly than 'HsDocTy', yet for constructor arguments we
      really need the 'HsBangTy' on the outside.
      
      This commit does this shuffling in the 'mkConDeclH98' and 'mkGadtDecl'
      smart constructors.
      
      Test Plan: haddockA038, haddockC038
      
      Reviewers: bgamari, dfeuer
      
      Reviewed By: bgamari
      
      Subscribers: dfeuer, rwbarton, thomie, carter
      
      Differential Revision: https://phabricator.haskell.org/D4727
      0361fc03
    • Andreas Klebinger's avatar
      Check if both branches of an Cmm if have the same target. · efea32cf
      Andreas Klebinger authored
      This for some reason or the other and makes it into the final
      binary. I've added the check to ContFlowOpt as that seems
      like a logical place for this.
      
      In a regular nofib run there were 30 occurences of this pattern.
      
      Test Plan: ci
      
      Reviewers: bgamari, simonmar, dfeuer, jrtc27, tdammers
      
      Reviewed By: bgamari, simonmar
      
      Subscribers: tdammers, dfeuer, rwbarton, thomie, carter
      
      GHC Trac Issues: #15188
      
      Differential Revision: https://phabricator.haskell.org/D4740
      efea32cf
    • Andreas Herrmann's avatar
      Fix unparseable pretty-printing of promoted data cons · 767536cc
      Andreas Herrmann authored
      Previously we would print code which would not round-trip:
      ```
      > :set -XDataKinds
      > :set -XPolyKinds
      > data Proxy k = Proxy
      > _ :: Proxy '[ 'True ]
      error:
        Found hole: _ :: Proxy '['True]
      > _ :: Proxy '['True]
      error:
          Invalid type signature: _ :: ...
          Should be of form <variable> :: <type>
      ```
      
      Test Plan: Validate with T14343
      
      Reviewers: RyanGlScott, goldfire, bgamari, tdammers
      
      Reviewed By: RyanGlScott, bgamari
      
      Subscribers: tdammers, rwbarton, thomie, carter
      
      GHC Trac Issues: #14343
      
      Differential Revision: https://phabricator.haskell.org/D4746
      767536cc
    • David Feuer's avatar
      Index arrays more eagerly · e7678d6a
      David Feuer authored
      Many basic functions in `GHC.Arr` were unreasonably lazy about
      performing array lookups. This could lead to useless thunks
      at best and memory leaks at worst. Use eager lookups where
      they're obviously appropriate.
      
      Reviewers: bgamari, hvr
      
      Reviewed By: bgamari
      
      Subscribers: rwbarton, thomie, carter
      
      Differential Revision: https://phabricator.haskell.org/D4773
      e7678d6a
    • Ben Gamari's avatar
      WorkWrap: Rip out unsafeGlobalDynFlags usage in mkWwInlineRule · db4f064e
      Ben Gamari authored
      Subscribers: rwbarton, thomie, carter
      
      Differential Revision: https://phabricator.haskell.org/D4775
      db4f064e
    • Ben Gamari's avatar
      Don't use unsafeGlobalDynFlags in optCoercion · 64c71ce9
      Ben Gamari authored
      This plumbs DynFlags through CoreOpt so optCoercion can finally
      eliminate its usage of `unsafeGlobalDynFlags`.
      
      Note that this doesn't completely eliminate `unsafeGlobalDynFlags`
      usage from this bit of the compiler. A few uses are introduced in
      call-sites where we don't (yet) have ready access to `DynFlags`.
      
      Test Plan: Validate
      
      Reviewers: goldfire
      
      Subscribers: rwbarton, thomie, carter
      
      Differential Revision: https://phabricator.haskell.org/D4774
      64c71ce9
    • Ben Gamari's avatar
      Update hadrian submodule · f7417118
      Ben Gamari authored
      f7417118
    • Ben Gamari's avatar
      testsuite: Fix dynamic-paper stderr file · 1508600c
      Ben Gamari authored
      The stderr file was empty, yet GHC fails with an error.
      1508600c
    • Simon Peyton Jones's avatar
      Remove ad-hoc special case in occAnal · c16382d5
      Simon Peyton Jones authored
      Back in 1999 I put this ad-hoc code in the Case-handling
      code for occAnal:
      
        occAnal env (Case scrut bndr ty alts)
         = ...
              -- Note [Case binder usage]
              -- ~~~~~~~~~~~~~~~~~~~~~~~~
              -- The case binder gets a usage of either "many" or "dead", never "one".
              -- Reason: we like to inline single occurrences, to eliminate a binding,
              -- but inlining a case binder *doesn't* eliminate a binding.
              -- We *don't* want to transform
              --      case x of w { (p,q) -> f w }
              -- into
              --      case x of w { (p,q) -> f (p,q) }
          tag_case_bndr usage bndr
            = (usage', setIdOccInfo bndr final_occ_info)
            where
              occ_info       = lookupDetails usage bndr
              usage'         = usage `delDetails` bndr
              final_occ_info = case occ_info of IAmDead -> IAmDead
                                                _       -> noOccInfo
      
      But the comment looks wrong -- the bad inlining will not happen -- and
      I think it relates to some long-ago version of the simplifier.
      
      So I simply removed the special case, which gives more accurate
      occurrence-info to the case binder.  Interestingly I got a slight
      improvement in nofib binary sizes.
      
      --------------------------------------------------------------------------------
              Program           Size    Allocs   Runtime   Elapsed  TotalMem
      --------------------------------------------------------------------------------
            cacheprof          -0.1%     +0.2%     -0.7%     -1.2%     +8.6%
      --------------------------------------------------------------------------------
                  Min          -0.2%      0.0%    -14.5%    -30.5%      0.0%
                  Max          -0.1%     +0.2%    +10.0%    +10.0%    +25.0%
       Geometric Mean          -0.2%     +0.0%     -1.9%     -5.4%     +0.3%
      
      I have no idea if the improvement in runtime is real.  I did look at the
      tiny increase in allocation for cacheprof and concluded that it was
      unimportant (I forget the details).
      
      Also the more accurate occ-info for the case binder meant that some
      inlining happens in one pass that previously took successive passes
      for the test dependent/should_compile/dynamic-paper (which has a
      known Russel-paradox infinite loop in the simplifier).
      
      In short, a small win: less ad-hoc complexity and slightly smaller
      binaries.
      c16382d5
    • Simon Peyton Jones's avatar
      Comments only · 7f459064
      Simon Peyton Jones authored
      7f459064
    • Ömer Sinan Ağacan's avatar
      Do not scavenge SMALL_MUT_ARR_PTRS_CLEAN in mut_lists · 635a59a5
      Ömer Sinan Ağacan authored
      For the same reason with MUT_ARR_PTRS_CLEAN we don't need to scavenge
      SMALL_MUT_ARR_PTRS_CLEAN in mut_lists.
      
      Because SMALL_MUT_ARR_PTRS doesn't have a card table we don't have a
      special case when scavenging SMALL_MUT_ARR_PTRS_DIRTY in a mut_list.
      
      Test Plan: this validates
      
      Reviewers: simonmar, bgamari, erikd
      
      Reviewed By: simonmar, bgamari
      
      Subscribers: rwbarton, thomie, carter
      
      Differential Revision: https://phabricator.haskell.org/D4800
      635a59a5
  2. 06 Jun, 2018 1 commit
  3. 05 Jun, 2018 3 commits
    • Ömer Sinan Ağacan's avatar
      rts: Reuse dbl_link_remove in a few places · 455477a3
      Ömer Sinan Ağacan authored
      Test Plan: this validates
      
      Reviewers: simonmar, bgamari, erikd
      
      Reviewed By: simonmar
      
      Subscribers: rwbarton, thomie, carter
      
      Differential Revision: https://phabricator.haskell.org/D4795
      455477a3
    • Ömer Sinan Ağacan's avatar
      Rename some mutable closure types for consistency · 4075656e
      Ömer Sinan Ağacan authored
      SMALL_MUT_ARR_PTRS_FROZEN0 -> SMALL_MUT_ARR_PTRS_FROZEN_DIRTY
      SMALL_MUT_ARR_PTRS_FROZEN  -> SMALL_MUT_ARR_PTRS_FROZEN_CLEAN
      MUT_ARR_PTRS_FROZEN0       -> MUT_ARR_PTRS_FROZEN_DIRTY
      MUT_ARR_PTRS_FROZEN        -> MUT_ARR_PTRS_FROZEN_CLEAN
      
      Naming is now consistent with other CLEAR/DIRTY objects (MVAR, MUT_VAR,
      MUT_ARR_PTRS).
      
      (alternatively we could rename MVAR_DIRTY/MVAR_CLEAN etc. to MVAR0/MVAR)
      
      Removed a few comments in Scav.c about FROZEN0 being on the mut_list
      because it's now clear from the closure type.
      
      Reviewers: bgamari, simonmar, erikd
      
      Reviewed By: simonmar
      
      Subscribers: rwbarton, thomie, carter
      
      Differential Revision: https://phabricator.haskell.org/D4784
      4075656e
    • Ryan Scott's avatar
      Introduce DerivingVia · 8ed8b037
      Ryan Scott authored
      This implements the `DerivingVia` proposal put forth in
      https://github.com/ghc-proposals/ghc-proposals/pull/120.
      
      This introduces the `DerivingVia` deriving strategy. This is a
      generalization of `GeneralizedNewtypeDeriving` that permits the user
      to specify the type to `coerce` from.
      
      The major change in this patch is the introduction of the
      `ViaStrategy` constructor to `DerivStrategy`, which takes a type
      as a field. As a result, `DerivStrategy` is no longer a simple
      enumeration type, but rather something that must be renamed and
      typechecked. The process by which this is done is explained more
      thoroughly in section 3 of this paper
      ( https://www.kosmikus.org/DerivingVia/deriving-via-paper.pdf ),
      although I have inlined the relevant parts into Notes where possible.
      
      There are some knock-on changes as well. I took the opportunity to
      do some refactoring of code in `TcDeriv`, especially the
      `mkNewTypeEqn` function, since it was bundling all of the logic for
      (1) deriving instances for newtypes and
      (2) `GeneralizedNewtypeDeriving`
      into one huge broth. `DerivingVia` reuses much of part (2), so that
      was factored out as much as possible.
      
      Bumps the Haddock submodule.
      
      Test Plan: ./validate
      
      Reviewers: simonpj, bgamari, goldfire, alanz
      
      Subscribers: alanz, goldfire, rwbarton, thomie, mpickering, carter
      
      GHC Trac Issues: #15178
      
      Differential Revision: https://phabricator.haskell.org/D4684
      8ed8b037
  4. 04 Jun, 2018 12 commits
    • Simon Jakobi's avatar
      Serialize docstrings to ifaces, display them with new GHCi :doc command · 85309a3c
      Simon Jakobi authored
      If `-haddock` is set, we now extract docstrings from the renamed ast
      and serialize them in the .hi-files.
      
      This includes some of the changes from D4749 with the notable
      exceptions of the docstring lexing and renaming.
      
      A currently limited and experimental GHCi :doc command can be used
      to display docstrings for declarations.
      
      The formatting of pretty-printed docstrings is changed slightly,
      causing some changes in testsuite/tests/haddock.
      
      Test Plan: ./validate
      
      Reviewers: alexbiehl, hvr, gershomb, harpocrates, bgamari
      
      Reviewed By: alexbiehl
      
      Subscribers: rwbarton, thomie, carter
      
      Differential Revision: https://phabricator.haskell.org/D4758
      85309a3c
    • Andreas Klebinger's avatar
      Also suppress uniques in cmm dumps with `-dsuppress-uniques`. · aa77c602
      Andreas Klebinger authored
      Allows easier structural comparison of Cmm code.
      
      Before:
      ```
             cxCH: // global
                 _suEU::P64 = R1;
                 if ((Sp + -16) < SpLim) (likely: False) goto cxCI; else goto
      cxCJ;
      ```
      
      After
      ```
             _lbl_: // global
                 __locVar_::P64 = R1;
                 if ((Sp + -16) < SpLim) (likely: False) goto cxBf; else goto
      cxBg;
      ```
      
      Test Plan: Looking at dumps, ci
      
      Reviewers: bgamari, simonmar
      
      Reviewed By: bgamari
      
      Subscribers: rwbarton, thomie, carter
      
      Differential Revision: https://phabricator.haskell.org/D4786
      aa77c602
    • Matthew Pickering's avatar
      Improve extendTvSubst assertion · 97cea315
      Matthew Pickering authored
      Reviewers: bgamari
      
      Reviewed By: bgamari
      
      Subscribers: rwbarton, thomie, carter
      
      Differential Revision: https://phabricator.haskell.org/D4790
      97cea315
    • Matthew Pickering's avatar
      Add Outputable instance for HsArg · 1a61c6b8
      Matthew Pickering authored
      Reviewers: bgamari
      
      Reviewed By: bgamari
      
      Subscribers: rwbarton, thomie, carter
      
      Differential Revision: https://phabricator.haskell.org/D4791
      1a61c6b8
    • Simon Peyton Jones's avatar
      Implement QuantifiedConstraints · 7df58960
      Simon Peyton Jones authored
      We have wanted quantified constraints for ages and, as I hoped,
      they proved remarkably simple to implement.   All the machinery was
      already in place.
      
      The main ticket is Trac #2893, but also relevant are
        #5927
        #8516
        #9123 (especially!  higher kinded roles)
        #14070
        #14317
      
      The wiki page is
        https://ghc.haskell.org/trac/ghc/wiki/QuantifiedConstraints
      which in turn contains a link to the GHC Proposal where the change
      is specified.
      
      Here is the relevant Note:
      
      Note [Quantified constraints]
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      The -XQuantifiedConstraints extension allows type-class contexts like
      this:
      
        data Rose f x = Rose x (f (Rose f x))
      
        instance (Eq a, forall b. Eq b => Eq (f b))
              => Eq (Rose f a)  where
          (Rose x1 rs1) == (Rose x2 rs2) = x1==x2 && rs1 >= rs2
      
      Note the (forall b. Eq b => Eq (f b)) in the instance contexts.
      This quantified constraint is needed to solve the
       [W] (Eq (f (Rose f x)))
      constraint which arises form the (==) definition.
      
      Here are the moving parts
        * Language extension {-# LANGUAGE QuantifiedConstraints #-}
          and add it to ghc-boot-th:GHC.LanguageExtensions.Type.Extension
      
        * A new form of evidence, EvDFun, that is used to discharge
          such wanted constraints
      
        * checkValidType gets some changes to accept forall-constraints
          only in the right places.
      
        * Type.PredTree gets a new constructor ForAllPred, and
          and classifyPredType analyses a PredType to decompose
          the new forall-constraints
      
        * Define a type TcRnTypes.QCInst, which holds a given
          quantified constraint in the inert set
      
        * TcSMonad.InertCans gets an extra field, inert_insts :: [QCInst],
          which holds all the Given forall-constraints.  In effect,
          such Given constraints are like local instance decls.
      
        * When trying to solve a class constraint, via
          TcInteract.matchInstEnv, use the InstEnv from inert_insts
          so that we include the local Given forall-constraints
          in the lookup.  (See TcSMonad.getInstEnvs.)
      
        * topReactionsStage calls doTopReactOther for CIrredCan and
          CTyEqCan, so they can try to react with any given
          quantified constraints (TcInteract.matchLocalInst)
      
        * TcCanonical.canForAll deals with solving a
          forall-constraint.  See
             Note [Solving a Wanted forall-constraint]
             Note [Solving a Wanted forall-constraint]
      
        * We augment the kick-out code to kick out an inert
          forall constraint if it can be rewritten by a new
          type equality; see TcSMonad.kick_out_rewritable
      
      Some other related refactoring
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      
      * Move SCC on evidence bindings to post-desugaring, which fixed
        #14735, and is generally nicer anyway because we can use
        existing CoreSyn free-var functions.  (Quantified constraints
        made the free-vars of an ev-term a bit more complicated.)
      
      * In LookupInstResult, replace GenInst with OneInst and NotSure,
        using the latter for multiple matches and/or one or more
        unifiers
      7df58960
    • Andreas Klebinger's avatar
      Document the fact that cmm dumps won't show unreachable blocks. · 36091ec9
      Andreas Klebinger authored
      Reviewers: bgamari
      
      Reviewed By: bgamari
      
      Subscribers: rwbarton, thomie, carter
      
      Differential Revision: https://phabricator.haskell.org/D4788
      36091ec9
    • Tao He's avatar
      Fix broken test T14547. · d8efb098
      Tao He authored
      Phab:D4571 lags behind HEAD for too many commits. The commit of
      Phab:4571 1f88f541 brought some
      unintentional changes (not belong to [Phab:4571's Diff
      16314](https://phabricator.haskell.org/differential/diff/16314/)) into
      ghc-head, breaking T14557.
      
      Let's fix that.
      
      Test Plan: make test TEST="T14547"
      
      Reviewers: bgamari
      
      Reviewed By: bgamari
      
      Subscribers: rwbarton, thomie, carter
      
      GHC Trac Issues: #15222
      
      Differential Revision: https://phabricator.haskell.org/D4778
      d8efb098
    • Ben Gamari's avatar
      Bump stm and haskeline submodules · c560f382
      Ben Gamari authored
      c560f382
    • Simon Peyton Jones's avatar
      Refactor SetLevels.abstractVars · a1a507a1
      Simon Peyton Jones authored
      This patch is pure refactoring: using utility functions
      rather than special-purpose code, especially for closeOverKinds
      a1a507a1
    • Simon Peyton Jones's avatar
      Expand type synonyms when Linting a forall · 9d600ea6
      Simon Peyton Jones authored
      Trac #14939 showed a type like
         type Alg cls ob = ob
         f :: forall (cls :: * -> Constraint) (b :: Alg cls *). b
      
      where the kind of the forall looks like (Alg cls *), with a
      free cls. This tripped up Core Lint.
      
      I fixed this by making Core Lint a bit more forgiving, expanding
      type synonyms if necessary.
      
      I'm worried that this might not be the whole story; notably
      typeKind looks suspect.  But it certainly fixes this problem.
      9d600ea6
    • Simon Peyton Jones's avatar
      Do a late CSE pass · 0e5d2b74
      Simon Peyton Jones authored
      When investigating something else I found that a condition
      was being re-evaluated in wheel-seive1.  Why, when CSE should
      find it?  Because the opportunity only showed up after
      LiberateCase
      
      This patch adds a late CSE pass. Rather than give it an extra
      flag I do it when (cse && (spec_constr || liberate_case)), so
      roughly speaking it happense with -O2.
      
      In any case, CSE is very cheap.
      
      Nofib results are minor but in the right direction:
      
              Program           Size    Allocs   Runtime   Elapsed  TotalMem
      --------------------------------------------------------------------------------
                 anna          -0.1%     -0.0%     0.163     0.163      0.0%
                eliza          -0.1%     -0.4%     0.001     0.001      0.0%
                 fft2          -0.1%      0.0%     0.087     0.087      0.0%
                 mate          -0.0%     -1.3%     -0.8%     -0.8%      0.0%
            paraffins          -0.0%     -0.1%     +0.9%     +0.9%      0.0%
                  pic          -0.0%     -0.1%     0.009     0.009      0.0%
         wheel-sieve1          -0.2%     -0.0%     -0.1%     -0.1%      0.0%
      --------------------------------------------------------------------------------
                  Min          -0.6%     -1.3%     -2.4%     -2.4%      0.0%
                  Max          +0.0%     +0.0%     +3.8%     +3.8%    +23.8%
       Geometric Mean          -0.0%     -0.0%     +0.2%     +0.2%     +0.2%
      0e5d2b74
    • Matthew Pickering's avatar
      Provide `getWithUserData` and `putWithUserData` · 554bc7fc
      Matthew Pickering authored
      Summary:
      This makes it possible to serialise Names and FastStrings in user
      programs, for example, when writing a source plugin.
      
      When writing my first source plugin, I wanted to serialise names but it
      wasn't possible easily without exporting additional constructors. This
      interface is sufficient and abstracts nicely over the symbol table and
      dictionary.
      
      Reviewers: alpmestan, bgamari
      
      Reviewed By: alpmestan
      
      Subscribers: rwbarton, thomie, carter
      
      GHC Trac Issues: #15223
      
      Differential Revision: https://phabricator.haskell.org/D4782
      554bc7fc
  5. 03 Jun, 2018 11 commits
    • Ben Gamari's avatar
      testsuite: Really mark T14547 as broken · 4dd1895b
      Ben Gamari authored
      4dd1895b
    • Ben Gamari's avatar
      testsuite: Mark T14547 as broken · b564eb7e
      Ben Gamari authored
      b564eb7e
    • Ryan Scott's avatar
      Add tests for #8128 and #8740 · 90e99c4c
      Ryan Scott authored
      Commit 08073e16 (#11066) ended up
      fixing these, fortunately enough.
      90e99c4c
    • Joachim Breitner's avatar
      Fix typo in OverloadedLabels docs · 61280373
      Joachim Breitner authored
      as helpfully reported by elpinal (#15217).
      61280373
    • Tao He's avatar
      Improve exhaustiveness checking for literal values and patterns, fix #14546 · 1f88f541
      Tao He authored
      Currently, we parse both the **integral literal** value and the patterns
      as `OverLit HsIntegral`.  For example:
      
      ```
        case 0::Int of
            0 -> putStrLn "A"
            1 -> putStrLn "B"
            _ -> putStrLn "C"
      ```
      
      When checking the exhaustiveness of pattern matching, we translate the
      `0` in value position as `PmOLit`, but translate the `0` and `1` in
      pattern position as `PmSLit`. The inconsistency leads to the failure of
      `eqPmLit` to detect the equality and report warning of "Pattern match is
      redundant" on pattern `0`, as reported in #14546. In this patch we
      remove the specialization of `OverLit` patterns, and keep the overloaded
      number literal in pattern as it is to maintain the consistency.  Now we
      can capture the exhaustiveness of pattern `0` and the redundancy of
      pattern `1` and `_`.
      
      For **string literals**, we parse the string literals as `HsString`.
      When  `OverloadedStrings` is enabled, it further be turned as `HsOverLit
      HsIsString`, whether it's type is `String` or not. For example:
      
      ```
        case "foo" of
            "foo" -> putStrLn "A"
            "bar" -> putStrLn "B"
            "baz" -> putStrLn "C"
      ```
      
      Previously, the overloaded string values are translated to `PmOLit` and
      the non-overloaded string values are translated to `PmSLit`. However the
      string patterns, both overloaded and non-overloaded, are translated to
      list of characters. The inconsistency leads to wrong warnings about
      redundant and non-exhaustive pattern matching warnings, as reported
      in #14546.
      
      In order to catch the redundant pattern in following case:
      
      ```
        case "foo" of
            ('f':_) -> putStrLn "A"
            "bar" -> putStrLn "B"
      ```
      
      In this patch, we translate non-overloaded string literals, both in
      value position and pattern position, as list of characters. For
      overloaded string literals, we only translate it to list of characters
      only when it's type is `stringTy`, since we know nothing about the
      `toString` methods.  But we know that if two overloaded strings are
      syntax equal, then they are equal. Then if it's type is not `stringTy`,
      we just translate it to `PmOLit`. We can still capture the
      exhaustiveness of pattern `"foo"` and the redundancy of pattern `"bar"`
      and `"baz"` in the following code:
      
      ```
      {-# LANGUAGE OverloadedStrings #-}
      main = do
        case "foo" of
            "foo" -> putStrLn "A"
            "bar" -> putStrLn "B"
            "baz" -> putStrLn "C"
      ```
      
      Test Plan: make test TEST="T14546"
      
      Reviewers: bgamari, simonpj
      
      Reviewed By: bgamari, simonpj
      
      Subscribers: simonpj, thomie, carter
      
      GHC Trac Issues: #14546
      
      Differential Revision: https://phabricator.haskell.org/D4571
      1f88f541
    • Andreas Klebinger's avatar
      Allow aligning of cmm procs at specific boundry · f68c2cb6
      Andreas Klebinger authored
      Allows to align CmmProcs at the given boundries.
      
      It makes performance usually worse but can be helpful
      to limit the effect of a unrelated function B becoming
      faster/slower after changing function A.
      
      Test Plan: ci, using it.
      
      Reviewers: bgamari
      
      Reviewed By: bgamari
      
      Subscribers: rwbarton, thomie, carter
      
      GHC Trac Issues: #15148
      
      Differential Revision: https://phabricator.haskell.org/D4706
      f68c2cb6
    • Alanas Plascinskas's avatar
      tcExtendTyVarEnv2 changed to tcExtendNameTyVarEnv · 9b7eec86
      Alanas Plascinskas authored
      Reviewers: mpickering, goldfire, bgamari
      
      Reviewed By: mpickering
      
      Subscribers: goldfire, rwbarton, thomie, carter
      
      GHC Trac Issues: #15017
      
      Differential Revision: https://phabricator.haskell.org/D4732
      9b7eec86
    • Tobias Dammers's avatar
      Turn "inaccessible code" error into a warning · 08073e16
      Tobias Dammers authored
      With GADTs, it is possible to write programs such that the type
      constraints make some code branches inaccessible.
      
      Take, for example, the following program ::
      
          {-# LANGUAGE GADTs #-}
      
          data Foo a where
           Foo1 :: Foo Char
           Foo2 :: Foo Int
      
          data TyEquality a b where
                  Refl :: TyEquality a a
      
          checkTEQ :: Foo t -> Foo u -> Maybe (TyEquality t u)
          checkTEQ x y = error "unimportant"
      
          step2 :: Bool
          step2 = case checkTEQ Foo1 Foo2 of
                   Just Refl -> True -- Inaccessible code
                   Nothing -> False
      
      Clearly, the `Just Refl` case cannot ever be reached, because the `Foo1`
      and `Foo2` constructors say `t ~ Char` and `u ~ Int`, while the `Refl`
      constructor essentially mandates `t ~ u`, and thus `Char ~ Int`.
      
      Previously, GHC would reject such programs entirely; however, in
      practice this is too harsh. Accepting such code does little harm, since
      attempting to use the "impossible" code will still produce errors down
      the chain, while rejecting it means we cannot legally write or generate
      such code at all.
      
      Hence, we turn the error into a warning, and provide
      `-Winaccessible-code` to control GHC's behavior upon encountering this
      situation.
      
      Test Plan: ./validate
      
      Reviewers: bgamari
      
      Reviewed By: bgamari
      
      Subscribers: rwbarton, thomie, carter
      
      GHC Trac Issues: #11066
      
      Differential Revision: https://phabricator.haskell.org/D4744
      08073e16
    • Ryan Scott's avatar
      Fix a bad interaction between GADTs and COMPLETE sets · 4d800448
      Ryan Scott authored
      As observed in #14059 (starting at comment 5), the error
      messages surrounding a program involving GADTs and a `COMPLETE` set
      became worse between 8.2 and 8.4. The culprit was a new validity
      check in 8.4 which filters out `COMPLETE` set candidates if a return
      type of any conlike in the set doesn't match the type of the
      scrutinee. However, this check was too conservative, since it removed
      perfectly valid `COMPLETE` sets that contained GADT constructors,
      which quite often have return types that don't match the type of a
      scrutinee.
      
      To fix this, I adopted the most straightforward possible solution of
      only performing this validity check on //pattern synonym//
      constructors, not //data// constructors.
      
      Note that this does not fix #14059 entirely, but instead simply fixes
      a particular buglet that was discovered in that ticket.
      
      Test Plan: make test TEST=T14059
      
      Reviewers: bgamari, mpickering
      
      Reviewed By: mpickering
      
      Subscribers: rwbarton, thomie, carter
      
      GHC Trac Issues: #14059
      
      Differential Revision: https://phabricator.haskell.org/D4752
      4d800448
    • David Feuer's avatar
      Remove ~# from surface syntax · 5b82ee69
      David Feuer authored
      For some reason, it seems that the `ConstraintKinds` commit
      introduced `~#` into Haskell syntax, in a pretty broken manner.
      Unless and until we have an actual story for unboxed equality,
      it doesn't make sense to expose it. Moreover, the way it was
      donet was wrong enough and small enough that it will probably be
      easier to start over if we do that. Yank it out.
      
      Reviewers: bgamari, RyanGlScott
      
      Reviewed By: RyanGlScott
      
      Subscribers: RyanGlScott, rwbarton, thomie, mpickering, carter
      
      GHC Trac Issues: #15209
      
      Differential Revision: https://phabricator.haskell.org/D4763
      5b82ee69
    • Tobias Dammers's avatar
      Handle abi-depends correctly in ghc-pkg · 1626fe60
      Tobias Dammers authored
      When inferring the correct abi-depends, we now look at all the package
      databases in the stack, up to and including the current one, because
      these are the ones that the current package can legally depend on. While
      doing so, we will issue warnings:
      
      - In verbose mode, we warn about every package that declares
        abi-depends:, whether we actually end up overriding them with the
        inferred ones or not ("possibly broken abi-depends").
      
      - Otherwise, we only warn about packages whose declared abi-depends
        does not match what we inferred ("definitely broken abi-depends").
      
      Reviewers: bgamari
      
      Reviewed By: bgamari
      
      Subscribers: rwbarton, thomie, carter
      
      GHC Trac Issues: #14381
      
      Differential Revision: https://phabricator.haskell.org/D4729
      1626fe60