1. 26 Sep, 2020 10 commits
  2. 24 Sep, 2020 9 commits
    • Hécate Moonlight's avatar
      007940d2
    • Sebastian Graf's avatar
    • Simon Peyton Jones's avatar
      Improve kind generalisation, error messages · 9fa26aa1
      Simon Peyton Jones authored
      This patch does two things:
      
      * It refactors GHC.Tc.Errors a bit.  In debugging Quick Look I was
        forced to look in detail at error messages, and ended up doing a bit
        of refactoring, esp in mkTyVarEqErr'.  It's still quite a mess, but
        a bit better, I think.
      
      * It makes a significant improvement to the kind checking of type and
        class declarations. Specifically, we now ensure that if kind
        checking fails with an unsolved constraint, all the skolems are in
        scope.  That wasn't the case before, which led to some obscure error
        messages; and occasional failures with "no skolem info" (eg #16245).
      
      Both of these, and the main Quick Look patch itself, affect a /lot/ of
      error messages, as you can see from the number of files changed.  I've
      checked them all; I think they are as good or better than before.
      
      Smaller things
      
      * I documented the various instances of VarBndr better.
        See Note [The VarBndr tyep and its uses] in GHC.Types.Var
      
      * Renamed GHC.Tc.Solver.simpl_top to simplifyTopWanteds
      
      * A bit of refactoring in bindExplicitTKTele, to avoid the
        footwork with Either.  Simpler now.
      
      * Move promoteTyVar from GHC.Tc.Solver to GHC.Tc.Utils.TcMType
      
      Fixes #16245 (comment 211369), memorialised as
        typecheck/polykinds/T16245a
      Also fixes the three bugs in #18640
      9fa26aa1
    • Simon Peyton Jones's avatar
      Implement Quick Look impredicativity · 97cff919
      Simon Peyton Jones authored
      This patch implements Quick Look impredicativity (#18126), sticking
      very closely to the design in
          A quick look at impredicativity, Serrano et al, ICFP 2020
      
      The main change is that a big chunk of GHC.Tc.Gen.Expr has been
      extracted to two new modules
          GHC.Tc.Gen.App
          GHC.Tc.Gen.Head
      which deal with typechecking n-ary applications, and the head of
      such applications, respectively.  Both contain a good deal of
      documentation.
      
      Three other loosely-related changes are in this patch:
      
      * I implemented (partly by accident) points (2,3)) of the accepted GHC
        proposal "Clean up printing of foralls", namely
        https://github.com/ghc-proposals/ghc-proposals/blob/
              master/proposals/0179-printing-foralls.rst
        (see #16320).
      
        In particular, see Note [TcRnExprMode] in GHC.Tc.Module
        - :type instantiates /inferred/, but not /specified/, quantifiers
        - :type +d instantiates /all/ quantifiers
        - :type +v is killed off
      
        That completes the implementation of the proposal,
        since point (1) was done in
          commit df084681
          Author: Krzysztof Gogolewski <krzysztof.gogolewski@tweag.io>
          Date:   Mon Feb 3 21:17:11 2020 +0100
          Always display inferred variables using braces
      
      * HsRecFld (which the renamer introduces for record field selectors),
        is now preserved by the typechecker, rather than being rewritten
        back to HsVar.  This is more uniform, and turned out to be more
        convenient in the new scheme of things.
      
      * The GHCi debugger uses a non-standard unification that allows the
        unification variables to unify with polytypes.  We used to hack
        this by using ImpredicativeTypes, but that doesn't work anymore
        so I introduces RuntimeUnkTv.  See Note [RuntimeUnkTv] in
        GHC.Runtime.Heap.Inspect
      
      Updates haddock submodule.
      
      WARNING: this patch won't validate on its own.  It was too
      hard to fully disentangle it from the following patch, on
      type errors and kind generalisation.
      
      Changes to tests
      
      * Fixes #9730 (test added)
      
      * Fixes #7026 (test added)
      
      * Fixes most of #8808, except function `g2'` which uses a
        section (which doesn't play with QL yet -- see #18126)
        Test added
      
      * Fixes #1330. NB Church1.hs subsumes Church2.hs, which is now deleted
      
      * Fixes #17332 (test added)
      
      * Fixes #4295
      
      * This patch makes typecheck/should_run/T7861 fail.
        But that turns out to be a pre-existing bug: #18467.
        So I have just made T7861 into expect_broken(18467)
      97cff919
    • syd@cs-syd.eu's avatar
    • Hécate Moonlight's avatar
    • Sylvain Henry's avatar
    • Sylvain Henry's avatar
      Remove sdocWithDynFlags (fix #10143) · a584366b
      Sylvain Henry authored
      a584366b
    • Sylvain Henry's avatar
      Refactor CLabel pretty-printing · 667d6355
      Sylvain Henry authored
      * Don't depend on the selected backend to know if we print Asm or C
        labels: we already have PprStyle to determine this. Moreover even when
        a native backend is used (NCG, LLVM) we may want to C headers
        containing pretty-printed labels, so it wasn't a good predicate
        anyway.
      
      * Make pretty-printing code clearer and avoid partiality
      667d6355
  3. 23 Sep, 2020 2 commits
  4. 22 Sep, 2020 4 commits
    • Sebastian Graf's avatar
      PmCheck: Rewrite inhabitation test · e9501547
      Sebastian Graf authored
      We used to produce inhabitants of a pattern-match refinement type Nabla
      in the checker in at least two different and mostly redundant ways:
      
        1. There was `provideEvidence` (now called
           `generateInhabitingPatterns`) which is used by
           `GHC.HsToCore.PmCheck` to produce non-exhaustive patterns, which
           produces inhabitants of a Nabla as a sub-refinement type where all
           match variables are instantiated.
        2. There also was `ensure{,All}Inhabited` (now called
           `inhabitationTest`) which worked slightly different, but was
           whenever new type constraints or negative term constraints were
           added. See below why `provideEvidence` and `ensureAllInhabited`
           can't be the same function, the main reason being performance.
        3. And last but not least there was the `nonVoid` test, which tested
           that a given type was inhabited. We did use this for strict fields
           and -XEmptyCase in the past.
      
      The overlap of (3) with (2) was always a major pet peeve of ...
      e9501547
    • Sebastian Graf's avatar
      6fe8a0c7
    • Simon Peyton Jones's avatar
      Fix the occurrence analyser · 416bd50e
      Simon Peyton Jones authored
      Ticket #18603 demonstrated that the occurrence analyser's
      handling of
      
        local RULES for imported Ids
      
      (which I now call IMP-RULES) was inadequate.  It led the simplifier
      into an infnite loop by failing to label a binder as a loop breaker.
      
      The main change in this commit is to treat IMP-RULES in a simple and
      uniform way: as extra rules for the local binder.  See
        Note [IMP-RULES: local rules for imported functions]
      
      This led to quite a bit of refactoring.  The result is still tricky,
      but it's much better than before, and better documented I think.
      
      Oh, and it fixes the bug.
      416bd50e
    • Simon Peyton Jones's avatar
      Better eta-expansion (again) and don't specilise DFuns · 6de40f83
      Simon Peyton Jones authored
      This patch fixes #18223, which made GHC generate an exponential
      amount of code.  There are three quite separate changes in here
      
      1.  Re-engineer eta-expansion (again).  The eta-expander was
          generating lots of intermediate stuff, which could be optimised
          away, but which choked the simplifier meanwhile.  Relatively
          easy to kill it off at source.
      
          See Note [The EtaInfo mechanism] in GHC.Core.Opt.Arity.
          The main new thing is the use of pushCoArg in getArg_maybe.
      
      2.  Stop Specialise specalising DFuns.  This is the cause of a huge
          (and utterly unnecessary) blowup in program size in #18223.
          See Note [Do not specialise DFuns] in GHC.Core.Opt.Specialise.
      
          I also refactored the Specialise monad a bit... it was silly,
          because it passed on unchanging values as if they were mutable
          state.
      
      3.  Do an extra Simplifer run, after SpecConstra and before
          late-Specialise.  I found (investigating perf/compiler/T16473)
          that failing to do this was crippling *both* SpecConstr *and*
          Specialise.  See Note [Simplify after SpecConstr] in
          GHC.Core.Opt.Pipeline.
      
          This change does mean an extra run of the Simplifier, but only
          with -O2, and I think that's acceptable.
      
          T16473 allocates *three* times less with this change.  (I changed
          it to check runtime rather than compile time.)
      
      Some smaller consequences
      
      * I moved pushCoercion, pushCoArg and friends from SimpleOpt
        to Arity, because it was needed by the new etaInfoApp.
      
        And pushCoValArg now returns a MCoercion rather than Coercion for
        the argument Coercion.
      
      * A minor, incidental improvement to Core pretty-printing
      
      This does fix #18223, (which was otherwise uncompilable. Hooray.  But
      there is still a big intermediate because there are some very deeply
      nested types in that program.
      
      Modest reductions in compile-time allocation on a couple of benchmarks
          T12425     -2.0%
          T13253    -10.3%
      
      Metric increase with -O2, due to extra simplifier run
          T9233     +5.8%
          T12227    +1.8%
          T15630    +5.0%
      
      There is a spurious apparent increase on heap residency on T9630,
      on some architectures at least.  I tried it with -G1 and the residency
      is essentially unchanged.
      
      Metric Increase
          T9233
          T12227
          T9630
      
      Metric Decrease
          T12425
          T13253
      6de40f83
  5. 21 Sep, 2020 11 commits
  6. 19 Sep, 2020 4 commits