When should -Wmissed-specializations fire?

While working on a fix for #16282 (closed), I noticed:

1. that -Wmissed-specializations doesn't fire when the docs say it should
2. that the "probable fix" suggested when a warning does fire is highly suspect

import Data.Map
main :: IO ()
main = do
  let m = [] :: [Map String Bool]
  mapM_ print m

With GHC 8.4.3, 8.6.3, and HEAD: ghc -O2 -Wmissed-specializations Main.hs does *not* issue any warnings.

However, in 8.6.3 and HEAD, ghc -O2 -Wall-missed-specializations Main.hs *does* create a warning:

Main.hs: warning: [-Wall-missed-specialisations]
    Could not specialise imported function ‘Data.Map.Internal.$w$cshowsPrec’
      when specialising ‘Data.Map.Internal.$fShowMap_$cshowsPrec’
    Probable fix: add INLINABLE pragma on ‘Data.Map.Internal.$w$cshowsPrec’

The docs for -Wmissed-specializations say, "warn when specialisation of an imported, overloaded function fails." Since showsPrec is an imported function, it seems that a warning should have been issued with -Wmissed-specs. My reading of the docs is that -Wall-missed-specs should output everything -Wmissed-specs does, along with any *local* overloaded and unspecialized functions.

Moreover, the "Probable fix" is suspect. A warning recommending an INLINABLE pragma is issued depending on the output of warnMissedSpec in specialise/Specialise.hs. For -Wall-missed-specs, warnMissedSpec doesn't check if an INLINABLE pragma is already present, so the fix could be redundant. For -Wmissed-specs, warnMissedSpecs *only* issues a warning if there *is* any inline pragma (of one sort of another) on all the callers, making the probable fix definitely redundant.

changed weight to 5

added Tbug Trac import labels

I should point out that the fact that -Wmissed-specs doesn't create a warning in the example above seems to (according to the code) be due to showsPrec not having any type of inline pragma. The following evaluates to False on f=showsPrec:

has_inline_prag f = isAnyInlinePragma (idInlinePragma f)

changed the description

It seems to me that -Wmissed-specs should warn when a function which has an INLINABLE pragma on fails to specialise for some reason and -Wall-missed-specs should warn whenever an overloaded function fails to specialise. Is that what the implementation does?

Nearly. -Wmissed-specs warns when an *imported* function which has *any* "inline" pragma (haven't dug into which are allowed) doesn't get specialized.

-Wall-missed-specs warns whenever any overloaded function fails to specialize, exactly as you say.

Questions are:

1. Should -Wmissed-specs warn in the example above?
2. What should the "Probable fix" be for either flag?

For what it's worth, here's the Note in Specialise.hs

{- Note [Warning about missed specialisations]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Suppose
 * In module Lib, you carefully mark a function 'foo' INLINABLE
 * Import Lib(foo) into another module M
 * Call 'foo' at some specialised type in M
Then you jolly well expect it to be specialised in M.  But what if
'foo' calls another function 'Lib.bar'.  Then you'd like 'bar' to be
specialised too.  But if 'bar' is not marked INLINABLE it may well
not be specialised.  The warning Opt_WarnMissedSpecs warns about this.

It's more noisy to warning about a missed specialisation opportunity
for /every/ overloaded imported function, but sometimes useful. That
is what Opt_WarnAllMissedSpecs does.

ToDo: warn about missed opportunities for local functions.

As I read the code it is trying to do this:

• -Wall-missed-specs: warn about any overloaded imported functions that cannot be specialised. Usually this means we don't have its RHS.
• -Wmissed-specs: warn about any overloaded imported functions that can't be specialised, and is transitively called by a chain of imported functions each with an INLINEABLE pragma.

For the latter consider

module A where
  import B
  foo = f (3::Int) + g (4::Int)

module B where
  f :: Num a => a -> a
  {-# INLINABLE f #-}
  f x = h x

  g x = Num a => a -> a
  g x = blah

  h x :: Num a => a -> a
  h x = blah

Then when compiling A, -Wmissed-specs is supposed to

• Not warn about not-specialising g, because g didn't have an INLINABLE pragma.
• Warn about non-specialising h because f (which is directly called from A) has a careful INLINABLE pragma, but h (perhaps due to an oversight) does not.

In contrast -Wall-missed-specs should warn about both.

Does that make sense? Is it what we want?

Looks like your assessment is accurate, Simon. Perhaps the only problem here is a documentation issue, because I don't think the docs for -Wmissed-specs make it clear when a warning is issued.

I'm also interested in understanding the warning from my example. The function names appear to be core, and it's not clear to me that Data.Map.Internal.$fShowMap_$cshowsPrec even corresponds to a function in source code. If that's the case, then the warning isn't very useful, either.

added error messages label

added Pnormal label

marked this issue as related to #20744 (closed)

I'm not quite happy with -Wmissed-specialisations in 9.2.2 (and it seems to work the same in HEAD ghc-9.3.20220316). When I do

git clone git@github.com:LambdaHack/LambdaHack.git
git checkout 7ed94b4b6c75fc46afeef01d8ac476c4598fb822
cabal build

the warnings I'm repeatedly getting are only

definition-src/Game/LambdaHack/Content/FactionKind.hs: warning: [-Wmissed-specialisations]
    Could not specialise imported function ‘blame’
      when specialising ‘makeContentData’
    Probable fix: add `INLINABLE pragma on ‘blame’

engine-src/Game/LambdaHack/Client/UI/Animation.hs: warning: [-Wmissed-specialisations]
    Could not specialise imported function ‘ghc-prim:GHC.Classes.$fEq[]_$c==’
      when specialising ‘ghc-prim:GHC.Classes.$fEq[]_$c/=’
    Probable fix: add INLINABLE pragma on ‘ghc-prim:GHC.Classes.$fEq[]_$c==’

and the first is clearly spurious, because the blame function is defined in external package assert-failure as

blame :: Show v => Bool -> v -> Bool
{-# NOINLINE blame #-}
blame True _ = True
blame False blamed = trace (blameMessage blamed) False

so it's definitely intended not to specialize and also I can't add INLINABLE to it, because it's on Hackage, I can't modify it. I don't pretend to understand the other warning.

I have -fexpose-all-unfoldings -fspecialise-aggressively in my .cabal file if that matters.