1. 19 Apr, 2018 1 commit
  2. 13 Apr, 2018 1 commit
    • Ryan Scott's avatar
      Bump version numbers: base-4.11.1.0, integer-gmp-1.0.2.0 · c4814ab6
      Ryan Scott authored
      This takes care of bumping the `base` and `integer-gmp`
      minor version numbers in anticipation of a GHC 8.4.2 release.
      
      While I was in town, I also filled in a `@since TODO` Haddock
      annotation for `powModSecInteger` in `integer-gmp` with
      `1.0.2.0`, and updated the changelog accordingly.
      
      Test Plan: ./validate
      
      Reviewers: hvr, goldfire, bgamari
      
      Reviewed By: bgamari
      
      Subscribers: thomie, carter
      
      GHC Trac Issues: #15025
      
      Differential Revision: https://phabricator.haskell.org/D4586
      c4814ab6
  3. 08 Nov, 2017 1 commit
    • Simon Peyton Jones's avatar
      Minimise provided dictionaries in pattern synonyms · 2c2f3cea
      Simon Peyton Jones authored
      Trac #14394 showed that it's possible to get redundant
      constraints in the inferred provided constraints of a pattern
      synonym.  This patch removes the redundancy with mkMinimalBySCs.
      
      To do this I had to generalise the type of mkMinimalBySCs slightly.
      And, to reduce confusing reversal, I made it stable: it now returns
      its result in the same order as its input.  That led to a raft of
      error message wibbles, mostly for the better.
      2c2f3cea
  4. 16 Oct, 2017 1 commit
  5. 21 Sep, 2017 1 commit
  6. 23 Jul, 2017 2 commits
  7. 12 Jun, 2017 1 commit
    • niteria's avatar
      Fix #13807 - foreign import nondeterminism · dcdc3916
      niteria authored
      The problem was that the generated label included
      a freshly assigned Unique value.
      
      Test Plan:
      Added a new test and looked at the generated stub:
      
      ```
       #include "HsFFI.h"
       #ifdef __cplusplus
       extern "C" {
       #endif
       extern HsInt zdmainzdAzdAzuzzlzzgzzg(StgStablePtr the_stableptr);
       extern HsInt zdmainzdAzdAzumkStringWriter(StgStablePtr the_stableptr);
       #ifdef __cplusplus
       }
       #endif
      ```
      
      ./validate
      
      Reviewers: simonmar, austin, bgamari
      
      Reviewed By: simonmar
      
      Subscribers: rwbarton, thomie
      
      GHC Trac Issues: #13807
      
      Differential Revision: https://phabricator.haskell.org/D3633
      dcdc3916
  8. 05 Apr, 2017 1 commit
  9. 10 Mar, 2017 1 commit
    • Simon Peyton Jones's avatar
      Fix TcSimplify.decideQuantification for kind variables · 7e96526a
      Simon Peyton Jones authored
      TcSimplify.decideQuantification was doing the Wrong Thing when
      "growing" the type variables to quantify over. We were trying to do
      this on a tyvar set where we'd split off the dependent type varaibles;
      and we just got it wrong.  A kind variable wasn't being generalised
      properly, with confusing knock on consequences.
      
      All this led to Trac #13371 and Trac #13393.
      
      This commit tidies it all up:
      
      * The type TcDepVars is renamed as CandidateQTvs;
        and splitDepVarsOfType to candidateQTyVarsOfType
      
      * The code in TcSimplify.decideQuantification is simpler.
        It no longer does the tricky "grow" stuff over TcDepVars.
        Instead it use ordinary VarSets (thereby eliminating the
        nasty growThetaTyVarsDSet) and uses that to filter the
        result of candidateQTyVarsOfType.
      
      * I documented that candidateQTyVarsOfType returns the type
        variables in a good order in which to quantify, and rewrote
        it to use an accumulator pattern, so that we would predicatably
        get left-to-right ordering.
      
      In doing all this I also made UniqDFM behave a little more nicely:
      
      * When inserting an element that is there already, keep the old tag,
        while still overwriting with the new value.
      
      * This means that when doing udfmToList we get back elements in the
        order they were originally inserted, rather than in reverse order.
      
      It's not a big deal, but in a subsequent commit I use it to improve
      the order of type variables in inferred types.
      
      All this led to a lot of error message wibbles:
       - changing the order of quantified variables
       - changing the order in which instances are listed in GHCi
       - changing the tidying of variables in typechecker erors
      
      There's a submodule update for 'array' because one of its tests
      has an error-message change.
      
      I may not have associated all of them with the correct commit.
      7e96526a
  10. 03 Mar, 2017 1 commit
  11. 26 Feb, 2017 1 commit
    • rwbarton's avatar
      tests: remove extra_files.py (#12223) · 3415bcaa
      rwbarton authored
      The script I used is included as testsuite/driver/kill_extra_files.py,
      though at this point it is for mostly historical interest.
      
      Some of the tests in libraries/hpc relied on extra_files.py, so this
      commit includes an update to that submodule.
      
      One test in libraries/process also relies on extra_files.py, but we
      cannot update that submodule so easily, so for now we special-case it
      in the test driver.
      3415bcaa
  12. 22 Jan, 2017 1 commit
    • thomie's avatar
      Remove clean_cmd and extra_clean usage from .T files · 5d38fb69
      thomie authored
      The `clean_cmd` and `extra_clean` setup functions don't do anything.
      Remove them from .T files.
      
      Created using https://github.com/thomie/refactor-ghc-testsuite. This
      diff is a test for the .T-file parser/processor/pretty-printer in that
      repository.
      
          find . -name '*.T' -exec ~/refactor-ghc-testsuite/Main "{}" \;
      
      Tests containing inline comments or multiline strings are not modified.
      
      Preparation for #12223.
      
      Test Plan: Harbormaster
      
      Reviewers: austin, hvr, simonmar, mpickering, bgamari
      
      Reviewed By: mpickering
      
      Subscribers: mpickering
      
      Differential Revision: https://phabricator.haskell.org/D3000
      
      GHC Trac Issues: #12223
      5d38fb69
  13. 15 Dec, 2016 1 commit
  14. 29 Nov, 2016 1 commit
    • Sylvain Henry's avatar
      Replace -fshow-source-paths with -fhide-source-paths · 3ec85630
      Sylvain Henry authored
      This patch reverts the change introduced with
      587dcccf and restores the previous
      default output of GHC (i.e., show source path and object path for each
      compiled module).
      
      The -fhide-source-paths flag can be used to hide these paths and reduce
      the line
      noise.
      
      Reviewers: gracjan, nomeata, austin, bgamari, simonmar, hvr
      
      Reviewed By: hvr
      
      Subscribers: thomie
      
      Differential Revision: https://phabricator.haskell.org/D2728
      
      GHC Trac Issues: #12851
      3ec85630
  15. 12 Nov, 2016 1 commit
  16. 30 Jun, 2016 2 commits
  17. 23 Jun, 2016 1 commit
    • niteria's avatar
      Provide Uniquable version of SCC · 35d1564c
      niteria authored
      We want to remove the `Ord Unique` instance because there's
      no way to implement it in deterministic way and it's too
      easy to use by accident.
      
      We sometimes compute SCC for datatypes whose Ord instance
      is implemented in terms of Unique. The Ord constraint on
      SCC is just an artifact of some internal data structures.
      We can have an alternative implementation with a data
      structure that uses Uniquable instead.
      
      This does exactly that and I'm pleased that I didn't have
      to introduce any duplication to do that.
      
      Test Plan:
      ./validate
      I looked at performance tests and it's a tiny bit better.
      
      Reviewers: bgamari, simonmar, ezyang, austin, goldfire
      
      Subscribers: thomie
      
      Differential Revision: https://phabricator.haskell.org/D2359
      
      GHC Trac Issues: #4012
      35d1564c
  18. 20 Jun, 2016 1 commit
  19. 08 Jun, 2016 1 commit
    • niteria's avatar
      Add some determinism tests · d4b548ef
      niteria authored
      These are the tests that I accumulated fixing real issues.
      Each test is a separate thing that was broken and they are
      relatively small.
      
      GHC Trac: #4012
      d4b548ef
  20. 06 Jun, 2016 1 commit
  21. 24 May, 2016 1 commit
    • niteria's avatar
      Make Arrow desugaring deterministic · 9d06ef1a
      niteria authored
      This kills two instances of varSetElems that turned out to be
      nondeterministic. I've tried to untangle this before, but it's
      a bit hard with the fixDs in the middle. Fortunately I now have
      a test case that proves that we need determinism here.
      
      Test Plan: ./validate, new testcase
      
      Reviewers: simonpj, simonmar, austin, bgamari
      
      Reviewed By: bgamari
      
      Subscribers: thomie
      
      Differential Revision: https://phabricator.haskell.org/D2258
      
      GHC Trac Issues: #4012
      9d06ef1a
  22. 29 Mar, 2016 1 commit
  23. 25 Feb, 2016 1 commit
  24. 27 Jan, 2016 1 commit
    • eir@cis.upenn.edu's avatar
      Refactor the typechecker to use ExpTypes. · 00cbbab3
      eir@cis.upenn.edu authored
      The idea here is described in [wiki:Typechecker]. Briefly,
      this refactor keeps solid track of "synthesis" mode vs
      "checking" in GHC's bidirectional type-checking algorithm.
      When in synthesis mode, the expected type is just an IORef
      to write to.
      
      In addition, this patch does a significant reworking of
      RebindableSyntax, allowing much more freedom in the types
      of the rebindable operators. For example, we can now have
      `negate :: Int -> Bool` and
      `(>>=) :: m a -> (forall x. a x -> m b) -> m b`. The magic
      is in tcSyntaxOp.
      
      This addresses tickets #11397, #11452, and #11458.
      
      Tests:
        typecheck/should_compile/{RebindHR,RebindNegate,T11397,T11458}
        th/T11452
      00cbbab3
  25. 26 Jan, 2016 1 commit
    • Ryan Scott's avatar
      Split off -Wunused-type-variables from -Wunused-matches · 6817703b
      Ryan Scott authored
      Summary:
      Previously, `-Wunused-matches` would fire whenever it detected unused type
      variables in a type family or data family instance. This can be annoying for
      users who wish to use type variable names as documentation, as being
      `-Wall`-compliant would mean that they'd have to prefix many of their type
      variable names with underscores, making the documentation harder to read.
      
      To avoid this, a new warning `-Wunused-type-variables` was created that only
      encompasses unused variables in family instances. `-Wunused-matches` reverts
      back to its role of only warning on unused term-level pattern names. Unlike
      `-Wunused-matches`, `-Wunused-type-variables` is not implied by `-Wall`.
      
      Fixes #11451.
      
      Test Plan: ./validate
      
      Reviewers: goldfire, ekmett, austin, hvr, simonpj, bgamari
      
      Reviewed By: simonpj, bgamari
      
      Subscribers: thomie
      
      Differential Revision: https://phabricator.haskell.org/D1825
      
      GHC Trac Issues: #11451
      6817703b
  26. 21 Dec, 2015 1 commit
    • msosn's avatar
      Warn about unused type variables in type families · eb7796f1
      msosn authored
      The warnings are enabled with the flag -fwarn-unused-matches, the same
      one that enables warnings on the term level.
      
      Identifiers starting with an underscore are now always parsed as type
      variables.  When the NamedWildCards extension is enabled, the renamer
      replaces those variables with named wildcards.
      
      An additional NameSet nwcs is added to LocalRdrEnv. It's used to keep
      names of the type variables that should be replaced with wildcards.
      
      While renaming HsForAllTy, when a name is explicitly bound it is removed
      from the nwcs NameSet. As a result, the renamer doesn't replace them in
      the quantifier body. (Trac #11098)
      
      Fixes #10982, #11098
      
      Reviewers: alanz, bgamari, hvr, austin, jstolarek
      
      Reviewed By: jstolarek
      
      Subscribers: goldfire, mpickering, RyanGlScott, thomie
      
      Differential Revision: https://phabricator.haskell.org/D1576
      
      GHC Trac Issues: #10982
      eb7796f1
  27. 04 Dec, 2015 1 commit
    • Bartosz Nitka's avatar
      Make callToPats deterministic in SpecConstr · 5b2b7e33
      Bartosz Nitka authored
      This fixes a non-determinism bug where where depending on the
      order of uniques allocated, the specialized workers would have different
      order of arguments.
      
      Compare:
      
      ```
        $s$wgo_s1CN :: Int# -> Int -> Int#
        [LclId, Arity=2, Str=DmdType <L,U><L,U>]
        $s$wgo_s1CN =
          \ (sc_s1CI :: Int#) (sc_s1CJ :: Int) ->
            case tagToEnum# @ Bool (<=# sc_s1CI 0#) of _ [Occ=Dead] {
              False ->
                $wgo_s1BU (Just @ Int (I# (-# sc_s1CI 1#))) (Just @ Int sc_s1CJ);
              True -> 0#
            }
      ```
      
      vs
      
      ```
        $s$wgo_s18mTj :: Int -> Int# -> Int#
        [LclId, Arity=2, Str=DmdType <L,U><L,U>]
        $s$wgo_s18mTj =
          \ (sc_s18mTn :: Int) (sc_s18mTo :: Int#) ->
            case tagToEnum# @ Bool (<=# sc_s18mTo 0#) of _ [Occ=Dead] {
              False ->
                $wgo_s18mUc
                  (Just @ Int (I# (-# sc_s18mTo 1#))) (Just @ Int sc_s18mTn);
              True -> 0#
            }
      ```
      
      Test Plan:
      I've added a new testcase
      ./validate
      
      Reviewers: simonmar, simonpj, austin, goldfire, bgamari
      
      Reviewed By: bgamari
      
      Subscribers: thomie
      
      Differential Revision: https://phabricator.haskell.org/D1508
      
      GHC Trac Issues: #4012
      5b2b7e33
  28. 02 Dec, 2015 1 commit
  29. 01 Dec, 2015 1 commit
    • Bartosz Nitka's avatar
      Make the determinism tests more robust · b432e2f3
      Bartosz Nitka authored
      The tests weren't explicit enough about comparing under different
      unique allocation strategies. This led to some confusion on my part when
      I started overriding flags in `testsuite/mk/test.mk`.
      Includes a `.gitignore` rule.
      
      Test Plan: harbormaster
      
      Reviewers: austin, simonmar, bgamari
      
      Reviewed By: bgamari
      
      Subscribers: thomie
      
      Differential Revision: https://phabricator.haskell.org/D1555
      b432e2f3
  30. 22 Nov, 2015 1 commit
    • niteria's avatar
      Make abstractVars deterministic in SetLevel · 6393dd8e
      niteria authored
      This fixes a non-determinism bug where depending on the order
      of uniques allocated, the type variables would be in a different order
      when abstracted for the purpose of lifting out an expression.
      
      Test Plan:
      I've added a new testcase that reproduces the problem
      ./validate
      
      Reviewers: simonmar, austin, bgamari, simonpj
      
      Reviewed By: simonpj
      
      Subscribers: nomeata, thomie
      
      Differential Revision: https://phabricator.haskell.org/D1504
      
      GHC Trac Issues: #4012
      6393dd8e
  31. 11 Nov, 2015 1 commit
    • niteria's avatar
      Put kind variables before type variables when specializing · 0f495083
      niteria authored
      When you reverse the order of uniques you get the core lint
      error from the testcase. The testcase is copied from
      tests/simplCore/should_compile/T10689a.hs.
      
      The problem is that we would put type and kind variables ordered by
      unique order, which happened to be the right order for this testcase to
      pass under normal conditions.
      
      I think it's enough to sort them with `sortQuantVars`, but I'm not
      really sure if some more sophisticated dependency analysis isn't needed.
      
      Test Plan: added a new testcase
      
      Reviewers: simonpj, goldfire, simonmar, austin, bgamari
      
      Reviewed By: bgamari
      
      Subscribers: thomie
      
      Differential Revision: https://phabricator.haskell.org/D1457
      0f495083
  32. 30 Oct, 2015 1 commit
    • niteria's avatar
      Make type-class dictionary let binds deterministic · a5cb27f3
      niteria authored
      When generating dictionary let binds in dsTcEvBinds we may
      end up generating them in arbitrary order according to Unique order.
      
      Consider:
      
      ```
      let $dEq = GHC.Classes.$fEqInt in
      let $$dNum = GHC.Num.$fNumInt in ...
      ```
      
      vs
      
      ```
      let $dNum = GHC.Num.$fNumInt in
      let $dEq = GHC.Classes.$fEqInt in ...
      ```
      
      The way this change fixes it is by using `UniqDFM` - a type of
      deterministic finite maps of things keyed on `Unique`s. This way when
      you pull out evidence variables corresponding to type-class dictionaries
      they are in deterministic order.
      
      Currently it's the order of insertion and the way it's implemented is by
      tagging the values with the time of insertion.
      
      Test Plan:
      I've added a new test case to reproduce the issue.
      ./validate
      
      Reviewers: ezyang, simonmar, austin, simonpj, bgamari
      
      Reviewed By: simonmar, simonpj, bgamari
      
      Subscribers: thomie
      
      Differential Revision: https://phabricator.haskell.org/D1396
      
      GHC Trac Issues: #4012
      a5cb27f3
  33. 27 Oct, 2015 1 commit
    • niteria's avatar
      Sort field labels before fingerprint hashing · ffcdd84f
      niteria authored
      `fsEnvElts :: FastStringEnv a -> [a]` returns a list of `[a]` in the order of
      `Unique`s which is arbitrary. In this case it gives a list of record fields in
      arbitrary order, from which we then extract the field labels to contribute to
      the record fingerprint. The arbitrary ordering of field labels introduces
      unnecessary nondeterminism in interface files as demonstrated by the test case.
      
      We sort `FastString` here. It's safe, because the only way that the `Unique`
      associated with the `FastString` is used in comparison is for equality. If the
      `Unique`s are different it fallbacks to comparing the actual `ByteString`.
      
      Reviewed By: ezyang, thomie, bgamari, austin
      
      Differential Revision: https://phabricator.haskell.org/D1373
      
      GHC Trac Issues: #4012
      ffcdd84f
  34. 22 Oct, 2015 1 commit
    • niteria's avatar
      Make stronglyConnCompFromEdgedVertices deterministic · 9cb192ce
      niteria authored
      This makes it so the result of computing SCC's depends on the order
      the nodes were passed to it, but not on the order on the user provided
      key type.
      The key type is usually `Unique` which is known to be nondeterministic.
      
      Test Plan:
      `text` and `aeson` become deterministic after this
      ./validate
      
      Compare compile time for `text`:
      ```
      $ cabal get text && cd text* && cabal sandbox init && cabal install
      --dependencies-only && time cabal build
      real    0m59.459s
      user    0m57.862s
      sys     0m1.185s
      $ cabal clean && time cabal build
      real    1m0.037s
      user    0m58.350s
      sys     0m1.199s
      $ cabal clean && time cabal build
      real    0m57.634s
      user    0m56.118s
      sys     0m1.202s
      $ cabal get text && cd text* && cabal sandbox init && cabal install
      --dependencies-only && time cabal build
      real    0m59.867s
      user    0m58.176s
      sys     0m1.188s
      $ cabal clean && time cabal build
      real    1m0.157s
      user    0m58.622s
      sys     0m1.177s
      $ cabal clean && time cabal build
      real    1m0.950s
      user    0m59.397s
      sys     0m1.083s
      ```
      
      Reviewers: ezyang, simonmar, austin, bgamari
      
      Reviewed By: simonmar, bgamari
      
      Subscribers: thomie
      
      Differential Revision: https://phabricator.haskell.org/D1268
      
      GHC Trac Issues: #4012
      9cb192ce