Top level module identifiers shadow imported identifiers

Let's try this out as a language pragma and see if we like it?

Artificial example:

{-# LANGUAGE TopLevelShadowsImports #-}
import Data.Monoid
(<>) = mappend
main = putStrLn ("Hello" <> " " <> "World")

Current behavior: error: ambiguous occurrence of (<>) Desired behavior: uses top-level definition of (<>), prints "hello world"

Trac metadata

Trac field	Value
Version
Type	FeatureRequest
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Compiler
Test case
Differential revisions
BlockedBy
Related
Blocking
CC
Operating system
Architecture

changed weight to 5

added Tfeature request Trac import labels

Even when such a pragma is active, I'd expect the shadow-warnings to be emitted

Slight extension suggestion: include explicitly imported identifiers together with top-level identifiers. So that:

1. If an identifier is imported both explicitly and implicitly (including Prelude), there is no ambiguity (the explicit import wins). This resolves situations where a module imported without an import list adds a conflicting identifier. As a side effect, many uses of hiding would be no longer necessary.
2. If an identifier is both imported explicitly and defined at top-level, there is an ambiguity (since this is very likely a programmer error).

Identifiers brought into scope by a (..) aren't considered explicitly imported for this purpose. Otherwise extending a module could silently change meaning of an identifier, e.g.:

module DepA
data A = Foo

module DepB -- version 1
data B = Bar

module Client
import DepA
import DepB(B(..))
-- use of Foo resolves to DepA.Foo

Then DepB changes:

module DepB -- version 2
data B = Bar | Foo

and now Foo in (unchanged) Client resolves to DepB.Foo, which is worse than the current situation.

Of course, the pragma's name would have to be changed.

Another idea is to make a per-binding pragma.

import Data.Monoid

{-# SHADOWS (<>) #-}
(<>) = mappend
main = putStrLn ("Hello" <> " " <> "World")

This technique avoids unintended shadowing, intentionally resolves ambiguity by shadowing imports, and shouldn't need to set off the regular shadow warnings.

This same technique could also be used to annotate imports:

import Foo

{-# SHADOWS foo, Bar(..) #-}
import OtherFoo

Just throwing that idea out there. Unlike hiding, the SHADOWS pragma could check to make sure that the replacement actually exists.

I've added an example of the problem with (..) in my comment above; so far as I can see, it applies to SHADOWS as well.

I wrote a proposal for the explicitly imported identifiers case here [1], which was discussed here [2]. #9702 is also relevant.

[1] https://www.haskell.org/haskellwiki/PermissiveImportsProposal [2] https://www.haskell.org/pipermail/glasgow-haskell-users/2014-October/025306.html

added Pnormal label