This isn't related to this PR, but what happens if a constructor is imported and only used to permit a coercion? Do we still emit an unused import warning?

Newtype unwrapping is possible as long as the newtype constructor is exported, unlike Haskell it doesn‘t have to be in scope, so there’s no need to import a constructor only to allow some coercions.

I'm not sure that approach is safe: it's quite common to define a newtype in a MyModule.Internal module where everything is exported, and then re-export the subset of that API which is considered public from a separate module MyModule.

I’ve rebased this pull request on top of #3937.

There’s now a CannotFindCoercedCtor error for when the constructor isn’t exported at all (so we don’t even know if it’s a newtype) and a CannotFindCoercedNewtypeCtor error for when the newtype constructor is exported but not imported.

@kl0tl do you think we should try to get this into 0.14.0? I think it would be good if we can. Would you mind resolving the conflicts when you get a chance?

I’ve rebased the pull request! The diff should be much nicer. I also added a DataDeclType field to the DataType constructor of TypeKind, so that a newtype constructor doesn’t have to be exported for us to know that it is a newtype. This allows us to get rid of the CannotFindCoercedCtor error and only throw CannotUnwrapHiddenNewtypeConstructor errors when we know that the failure is really due to an out of scope newtype constructor.

What do you think of CannotUnwrapHiddenNewtypeConstructor for the error? The constructor isn’t necessarily hidden after all, it might just not be imported. Perhaps CannotUnwrapOutOfScopeNewtypeConstructor would be more appropriate?

I actually feel like this should be a NoInstanceFound error rather than a separate code; the error is that the compiler can’t prove that it’s safe to coerce between the two types in question, which in PureScript is represented by the lack of a Coercible instance. I think it could be confusing that this error looks quite different from other NoInstanceFound errors which arise as a result of trying to coerce two types which aren’t Coercible.

I also have a slight worry with the wording of the error message, because to me the message sounds quite confident that the correct course of action is to import the constructor. In practice, if you receive this error, the answer may instead be “don’t do that”. For example, if you were trying to coerce an Array to a NonEmptyArray. I think a reminder that having the newtype constructor in scope will silence this error is warranted, but it should be secondary to the main piece of information, which is “I can’t prove that a coercion from type X to type Y is safe.”

Would you prefer that we add the MissingConstructorImportForCoercible constructor to ErrorMessageHint instead and accumulate hints in solveWanteds, so that the following:

module Example.N where

newtype N a = N a

module Example where

import Example.N (N)
import Safe.Coerce (coerce)

example :: forall a. a -> N a
example = coerce

yields

Error found:
at Example.purs:7:11 - 7:17 (line 7, column 11 - line 7, column 17)

  No type class instance was found for
                                
    Prim.Coerce.Coercible a0    
                          (N a0)
                                

  The newtype constructor N is not in scope.

while checking that type forall (a :: Type) (b :: Type). Coercible @Type a b => a -> b
  is at least as general as type a0 -> N a0
while checking that expression coerce
  has type a0 -> N a0
in value declaration example

where a0 is a rigid type variable
        bound at (line 7, column 11 - line 7, column 17)

See https://github.com/purescript/documentation/blob/master/errors/NoInstanceFound.md for more information,
or to contribute content related to this error.

?

That sounds more appealing to me, yes. I also think it would be good to make the connection between the constructor being in scope and the coercion being possible slightly more clear in the hint; perhaps something along the lines of "Performing this coercion requires the data constructor N to be in scope"?