1. 18 Feb, 2016 1 commit
    • Simon Peyton Jones's avatar
      (Another) minor refactoring of substitutions · b5292557
      Simon Peyton Jones authored
      No change in functionality here, but greater clarity:
      
      * In FamInstEnv.FlattenEnv, kill off the fi_in_scope field
        We are already maintaining an in-scope set in the fe_subst field,
        so it's silly do to it twice.
      
        (This isn't strictly connected to the rest of this patch, but
        the nomenclature changes below affect the same code, so I put
        them together.)
      
      * TyCoRep.extendTCVSubst used to take a TyVar or a CoVar and work
        out what to do, but in fact we almost always know which of the
        two we are doing.  So:
          - define extendTvSubst, extendCvSubst
          - and use them
      
      * Similar renamings in TyCoRep:
         - extendTCvSubstList        -->   extendTvSubstList
         - extendTCvSubstBinder      -->   extendTvSubstBinder
         - extendTCvSubstAndInScope  --> extendTvSubstAndInScope
      
      * Add Type.extendTvSubstWithClone, extendCvSubstWithClone
      
      * Similar nomenclature changes in Subst, SimplEnv, Specialise
      
      * Kill off TyCoRep.substTelescope (never used)
      b5292557
  2. 27 Jan, 2016 1 commit
  3. 26 Jan, 2016 1 commit
  4. 19 Jan, 2016 1 commit
    • niteria's avatar
      Check InScopeSet in substTy and provide substTyUnchecked · 9d33adb6
      niteria authored
      This adds sanity checks to `substTy` that implement:
      
      > when calling substTy subst ty it should be the case that the in-scope
      > set in the substitution is a superset of
      > * The free vars of the range of the substitution
      > * The free vars of ty minus the domain of the substitution
      
      and replaces violators with unchecked version. The violators were found
      by running the GHC test suite.
      
      This ensures that I can work on this incrementally and that what I fix won't
      be undone by some other change.
      
      It also includes a couple of fixes that I've already done.
      
      Test Plan: ./validate
      
      Reviewers: simonmar, goldfire, simonpj, austin, bgamari
      
      Reviewed By: simonpj, bgamari
      
      Subscribers: thomie
      
      Differential Revision: https://phabricator.haskell.org/D1792
      
      GHC Trac Issues: #11371
      9d33adb6
  5. 18 Jan, 2016 1 commit
    • Jan Stolarek's avatar
      Replace calls to `ptext . sLit` with `text` · b8abd852
      Jan Stolarek authored
      Summary:
      In the past the canonical way for constructing an SDoc string literal was the
      composition `ptext . sLit`.  But for some time now we have function `text` that
      does the same.  Plus it has some rules that optimize its runtime behaviour.
      This patch takes all uses of `ptext . sLit` in the compiler and replaces them
      with calls to `text`.  The main benefits of this patch are clener (shorter) code
      and less dependencies between module, because many modules now do not need to
      import `FastString`.  I don't expect any performance benefits - we mostly use
      SDocs to report errors and it seems there is little to be gained here.
      
      Test Plan: ./validate
      
      Reviewers: bgamari, austin, goldfire, hvr, alanz
      
      Subscribers: goldfire, thomie, mpickering
      
      Differential Revision: https://phabricator.haskell.org/D1784
      b8abd852
  6. 26 Dec, 2015 1 commit
  7. 24 Dec, 2015 1 commit
  8. 17 Dec, 2015 1 commit
    • eir@cis.upenn.edu's avatar
      Fix #11230. · 1722fa10
      eir@cis.upenn.edu authored
      Previously, we were optimizing away all case expressions over
      coercions with dead binders. But sometimes we want to force
      the coercion expression. Like when it contains an error.
      
      Test case: typecheck/should_run/T11230
      1722fa10
  9. 11 Dec, 2015 1 commit
    • eir@cis.upenn.edu's avatar
      Add kind equalities to GHC. · 67465497
      eir@cis.upenn.edu authored
      This implements the ideas originally put forward in
      "System FC with Explicit Kind Equality" (ICFP'13).
      
      There are several noteworthy changes with this patch:
       * We now have casts in types. These change the kind
         of a type. See new constructor `CastTy`.
      
       * All types and all constructors can be promoted.
         This includes GADT constructors. GADT pattern matches
         take place in type family equations. In Core,
         types can now be applied to coercions via the
         `CoercionTy` constructor.
      
       * Coercions can now be heterogeneous, relating types
         of different kinds. A coercion proving `t1 :: k1 ~ t2 :: k2`
         proves both that `t1` and `t2` are the same and also that
         `k1` and `k2` are the same.
      
       * The `Coercion` type has been significantly enhanced.
         The documentation in `docs/core-spec/core-spec.pdf` reflects
         the new reality.
      
       * The type of `*` is now `*`. No more `BOX`.
      
       * Users can write explicit kind variables in their code,
         anywhere they can write type variables. For backward compatibility,
         automatic inference of kind-variable binding is still permitted.
      
       * The new extension `TypeInType` turns on the new user-facing
         features.
      
       * Type families and synonyms are now promoted to kinds. This causes
         trouble with parsing `*`, leading to the somewhat awkward new
         `HsAppsTy` constructor for `HsType`. This is dispatched with in
         the renamer, where the kind `*` can be told apart from a
         type-level multiplication operator. Without `-XTypeInType` the
         old behavior persists. With `-XTypeInType`, you need to import
         `Data.Kind` to get `*`, also known as `Type`.
      
       * The kind-checking algorithms in TcHsType have been significantly
         rewritten to allow for enhanced kinds.
      
       * The new features are still quite experimental and may be in flux.
      
       * TODO: Several open tickets: #11195, #11196, #11197, #11198, #11203.
      
       * TODO: Update user manual.
      
      Tickets addressed: #9017, #9173, #7961, #10524, #8566, #11142.
      Updates Haddock submodule.
      67465497
  10. 21 Nov, 2015 1 commit
    • niteria's avatar
      Create a deterministic version of tyVarsOfType · 2325bd4e
      niteria authored
      I've run into situations where I need deterministic `tyVarsOfType` and
      this implementation achieves that and also brings an algorithmic
      improvement.  Union of two `VarSet`s takes linear time the size of the
      sets and in the worst case we can have `n` unions of sets of sizes
      `(n-1, 1), (n-2, 1)...` making it quadratic.
      
      One reason why we need deterministic `tyVarsOfType` is in `abstractVars`
      in `SetLevels`. When we abstract type variables when floating we want
      them to be abstracted in deterministic order.
      
      Test Plan: harbormaster
      
      Reviewers: simonpj, goldfire, austin, hvr, simonmar, bgamari
      
      Reviewed By: simonmar
      
      Subscribers: thomie
      
      Differential Revision: https://phabricator.haskell.org/D1468
      
      GHC Trac Issues: #4012
      2325bd4e
  11. 10 Oct, 2015 1 commit
  12. 16 Jul, 2015 1 commit
  13. 13 Jul, 2015 1 commit
    • Simon Peyton Jones's avatar
      Do not optimise RULE lhs in substRule · d073c770
      Simon Peyton Jones authored
      This was causing Trac #10627.
      See Note [Substitute lazily] in CoreSubst.
      
      The bug was introduced by
         commit 30c17e70
          Author: simonpj@microsoft.com <unknown>
          Date:   Thu Nov 25 17:23:56 2010 +0000
          Substitution should just substitute, not optimise
      
      The fix is not to optimise the RHS as well as not-optimising the LHS!
      The simplifier does the right thing in Simplify.simplRule
      d073c770
  14. 22 May, 2015 1 commit
    • Simon Peyton Jones's avatar
      Reduce magic for seqId · eae703aa
      Simon Peyton Jones authored
      An upcoming commit means that the RULES for 'seq' get only
      one value arg, not two.  This patch prepares for that by
      
      - reducing the arity of seq's built-in rule, to take one value arg
      - making 'seq' not inline on the LHS of RULES
      - and removing the horrid un-inlining in DsBinds.decomposeRuleLhs
      eae703aa
  15. 10 Apr, 2015 1 commit
  16. 16 Dec, 2014 1 commit
    • Peter Wortmann's avatar
      Source notes (Core support) · 993975d3
      Peter Wortmann authored
      This patch introduces "SourceNote" tickishs that link Core to the
      source code that generated it. The idea is to retain these source code
      links throughout code transformations so we can eventually relate
      object code all the way back to the original source (which we can,
      say, encode as DWARF information to allow debugging).  We generate
      these SourceNotes like other tickshs in the desugaring phase. The
      activating command line flag is "-g", consistent with the flag other
      compilers use to decide DWARF generation.
      
      Keeping ticks from getting into the way of Core transformations is
      tricky, but doable. The changes in this patch produce identical Core
      in all cases I tested -- which at this point is GHC, all libraries and
      nofib. Also note that this pass creates *lots* of tick nodes, which we
      reduce somewhat by removing duplicated and overlapping source
      ticks. This will still cause significant Tick "clumps" - a possible
      future optimization could be to make Tick carry a list of Tickishs
      instead of one at a time.
      
      (From Phabricator D169)
      993975d3
  17. 03 Dec, 2014 1 commit
  18. 16 Sep, 2014 1 commit
  19. 28 Aug, 2014 1 commit
    • Simon Peyton Jones's avatar
      Refactor unfoldings · 6e0f6ede
      Simon Peyton Jones authored
      There are two main refactorings here
      
      1.  Move the uf_arity field
             out of CoreUnfolding
             into UnfWhen
          It's a lot tidier there.  If I've got this right, no behaviour
          should change.
      
      2.  Define specUnfolding and use it in DsBinds and Specialise
           a) commons-up some shared code
           b) makes sure that Specialise correctly specialises DFun
              unfoldings (which it didn't before)
      
      The two got put together because both ended up interacting in the
      specialiser.
      
      They cause zero difference to nofib.
      6e0f6ede
  20. 20 Aug, 2014 1 commit
  21. 15 May, 2014 1 commit
    • Herbert Valerio Riedel's avatar
      Add LANGUAGE pragmas to compiler/ source files · 23892440
      Herbert Valerio Riedel authored
      In some cases, the layout of the LANGUAGE/OPTIONS_GHC lines has been
      reorganized, while following the convention, to
      
      - place `{-# LANGUAGE #-}` pragmas at the top of the source file, before
        any `{-# OPTIONS_GHC #-}`-lines.
      
      - Moreover, if the list of language extensions fit into a single
        `{-# LANGUAGE ... -#}`-line (shorter than 80 characters), keep it on one
        line. Otherwise split into `{-# LANGUAGE ... -#}`-lines for each
        individual language extension. In both cases, try to keep the
        enumeration alphabetically ordered.
        (The latter layout is preferable as it's more diff-friendly)
      
      While at it, this also replaces obsolete `{-# OPTIONS ... #-}` pragma
      occurences by `{-# OPTIONS_GHC ... #-}` pragmas.
      23892440
  22. 25 Mar, 2014 1 commit
  23. 23 Mar, 2014 1 commit
  24. 11 Mar, 2014 1 commit
    • Simon Peyton Jones's avatar
      Make SetLevels do substitution properly (fixes Trac #8714) · ef44a429
      Simon Peyton Jones authored
      Nowadays SetLevels floats case expressions as well as let-bindings,
      and case expressions bind type variables.  We need to clone all such
      floated binders, to avoid accidental name capture.  But I'd forgotten
      to substitute for the cloned type variables, causing #8714.  (In the
      olden days only Ids were cloned, from let-bindings.)
      
      This patch fixes the bug and does quite a bit of clean-up refactoring
      as well, by putting the context level in the LvlEnv.
      
      There is no effect on performance, except that nofib 'rewrite' improves
      allocations by 3%.  On investigation I think it was a fluke to do with
      loop-cutting in big letrec nests.  But at least it's a fluke in the
      right direction.
      
              Program           Size    Allocs   Runtime   Elapsed  TotalMem
      --------------------------------------------------------------------------------
                  Min          -0.4%     -3.0%    -19.4%    -19.4%    -26.7%
                  Max          -0.0%     +0.0%    +17.9%    +17.9%      0.0%
       Geometric Mean          -0.1%     -0.0%     -0.7%     -0.7%     -0.4%
      ef44a429
  25. 13 Feb, 2014 2 commits
  26. 11 Feb, 2014 3 commits
  27. 26 Jan, 2014 1 commit
  28. 08 Oct, 2013 1 commit
  29. 01 Oct, 2013 1 commit
  30. 29 Aug, 2013 1 commit
  31. 02 Aug, 2013 1 commit
  32. 30 May, 2013 1 commit
    • Simon Peyton Jones's avatar
      Make 'SPECIALISE instance' work again · 1ed04090
      Simon Peyton Jones authored
      This is a long-standing regression (Trac #7797), which meant that in
      particular the Eq [Char] instance does not get specialised.
      (The *methods* do, but the dictionary itself doesn't.)  So when you
      call a function
           f :: Eq a => blah
      on a string type (ie a=[Char]), 7.6 passes a dictionary of un-specialised
      methods.
      
      This only matters when calling an overloaded function from a
      specialised context, but that does matter in some programs.  I
      remember (though I cannot find the details) that Nick Frisby discovered
      this to be the source of some pretty solid performanc regresisons.
      
      Anyway it works now. The key change is that a DFunUnfolding now takes
      a form that is both simpler than before (the DFunArg type is eliminated)
      and more general:
      
      data Unfolding
        = ...
        | DFunUnfolding {     -- The Unfolding of a DFunId
          			-- See Note [DFun unfoldings]
            		  	--     df = /\a1..am. \d1..dn. MkD t1 .. tk
                              --                                 (op1 a1..am d1..dn)
           		      	--     	    	      	       	   (op2 a1..am d1..dn)
              df_bndrs :: [Var],      -- The bound variables [a1..m],[d1..dn]
              df_con   :: DataCon,    -- The dictionary data constructor (never a newtype datacon)
              df_args  :: [CoreExpr]  -- Args of the data con: types, superclasses and methods,
          }                           -- in positional order
      
      That in turn allowed me to re-enable the DFunUnfolding specialisation in
      DsBinds.  Lots of details here in TcInstDcls:
      	  Note [SPECIALISE instance pragmas]
      
      I also did some refactoring, in particular to pass the InScopeSet to
      exprIsConApp_maybe (which in turn means it has to go to a RuleFun).
      
      NB: Interface file format has changed!
      1ed04090
  33. 10 May, 2013 1 commit
  34. 04 Feb, 2013 1 commit
    • chak@cse.unsw.edu.au.'s avatar
      Fix tidying of vectorised code · 82a30378
      chak@cse.unsw.edu.au. authored
      * We need to keep the vectorised version of a variable alive while the original is alive.
      * This implies that the vectorised version needs to get into the iface if the original appears in an unfolding.
      82a30378
  35. 30 Jan, 2013 1 commit
  36. 02 Jan, 2013 1 commit
    • Simon Peyton Jones's avatar
      Define ListSetOps.getNth, and use it · b0c0cae7
      Simon Peyton Jones authored
      I was tracking down an error looking like
        Prelude.(!!): index too large
      which is very unhelpful.  This patch replaces at least some uses
      of (!!) in GHC with getNth, which has a more helpful error
      message (with DEBUG anyway)
      b0c0cae7
  37. 01 Jan, 2013 1 commit
    • Simon Peyton Jones's avatar
      Refactor the invariants for ClsInsts · 5efe9b11
      Simon Peyton Jones authored
      We now have the invariant for a ClsInst that the is_tvs field
      is always completely fresh type variables. See
      Note [Template tyvars are fresh] in InstEnv.
      
      (Previously we frehened them when extending the instance environment,
      but that seems messier because it was an invariant only when the
      ClsInst was in an InstEnv.  Moreover, there was an invariant that
      thet tyvars of the DFunid in the ClsInst had to match, and I have
      removed that invariant altogether; there is no need for it.)
      
      Other changes I made at the same time:
      
       * Make is_tvs into a *list*, in the right order for the dfun type
         arguments.  This removes the wierd need for the dfun to have the
         same tyvars as the ClsInst template, an invariant I have always
         hated. The cost is that we need to make it a VarSet when matching.
         We could cache an is_tv_set instead.
      
       * Add a cached is_cls field to the ClsInst, to save fishing
         the Class out of the DFun.  (Renamed is_cls to is_cls_nm.)
      
       * Make tcSplitDFunTy return the dfun args, not just the *number*
         of dfun args
      
       * Make InstEnv.instanceHead return just the *head* of the
         instance declaration.  Add instanceSig to return the whole
         thing.
      5efe9b11