• Simon Peyton Jones's avatar
    Improve handling of overloaded labels, literals, lists etc · 4196969c
    Simon Peyton Jones authored
    When implementing Quick Look I'd failed to remember that overloaded
    labels, like #foo, should be treated as a "head", so that they can be
    instantiated with Visible Type Application. This caused #19154.
    
    A very similar ticket covers overloaded literals: #19167.
    
    This patch fixes both problems, but (annoyingly, albeit temporarily)
    in two different ways.
    
    Overloaded labels
    
    I dealt with overloaded labels by buying fully into the
    Rebindable Syntax approach described in GHC.Hs.Expr
    Note [Rebindable syntax and HsExpansion].
    
    There is a good overview in GHC.Rename.Expr
    Note [Handling overloaded and rebindable constructs].
    That module contains much of the payload for this patch.
    
    Specifically:
    
    * Overloaded labels are expanded in the renamer, fixing #19154.
      See Note [Overloaded labels] in GHC.Rename.Expr.
    
    * Left and right sections used to have special code paths in the
      typechecker and desugarer.  Now we just expand them in the
      renamer. This is harder than it sounds.  See GHC.Rename.Expr
      Note [Left and right sections].
    
    * Infix operator applications are expanded in the typechecker,
      specifically in GHC.Tc.Gen.App.splitHsApps.  See
      Note [Desugar OpApp in the typechecker] in that module
    
    * ExplicitLists are expanded in the renamer, when (and only when)
      OverloadedLists is on.
    
    * HsIf is expanded in the renamer when (and only when) RebindableSyntax
      is on.  Reason: the coverage checker treats HsIf specially.  Maybe
      we could instead expand it unconditionally, and fix up the coverage
      checker, but I did not attempt that.
    
    Overloaded literals
    
    Overloaded literals, like numbers (3, 4.2) and strings with
    OverloadedStrings, were not working correctly with explicit type
    applications (see #19167).  Ideally I'd also expand them in the
    renamer, like the stuff above, but I drew back on that because they
    can occur in HsPat as well, and I did not want to to do the HsExpanded
    thing for patterns.
    
    But they *can* now be the "head" of an application in the typechecker,
    and hence something like ("foo" @T) works now.  See
    GHC.Tc.Gen.Head.tcInferOverLit.  It's also done a bit more elegantly,
    rather than by constructing a new HsExpr and re-invoking the
    typechecker. There is some refactoring around tcShortCutLit.
    
    Ultimately there is more to do here, following the Rebindable Syntax
    story.
    
    There are a lot of knock-on effects:
    
    * HsOverLabel and ExplicitList no longer need funny (Maybe SyntaxExpr)
      fields to support rebindable syntax -- good!
    
    * HsOverLabel, OpApp, SectionL, SectionR all become impossible in the
      output of the typecheker, GhcTc; so we set their extension fields to
      Void. See GHC.Hs.Expr Note [Constructor cannot occur]
    
    * Template Haskell quotes for HsExpanded is a bit tricky.  See
      Note [Quotation and rebindable syntax] in GHC.HsToCore.Quote.
    
    * In GHC.HsToCore.Match.viewLExprEq, which groups equal HsExprs for the
      purpose of pattern-match overlap checking, I found that dictionary
      evidence for the same type could have two different names.  Easily
      fixed by comparing types not names.
    
    * I did quite a bit of annoying fiddling around in GHC.Tc.Gen.Head and
      GHC.Tc.Gen.App to get error message locations and contexts right,
      esp in splitHsApps, and the HsExprArg type.  Tiresome and not very
      illuminating.  But at least the tricky, higher order, Rebuilder
      function is gone.
    
    * Some refactoring in GHC.Tc.Utils.Monad around contexts and locations
      for rebindable syntax.
    
    * Incidentally fixes #19346, because we now print renamed, rather than
      typechecked, syntax in error mesages about applications.
    
    The commit removes the vestigial module GHC.Builtin.RebindableNames,
    and thus triggers a 2.4% metric decrease for test MultiLayerModules
    (#19293).
    
    Metric Decrease:
        MultiLayerModules
        T12545
    4196969c
Var.hs 33.5 KB