Non-sensical error message when failing to parse InlineYaml from precompiled module

[martijnbastiaan]

If your (starter) project contains a primitive such as:

...
{-# NOINLINE foo #-}
{-# ANN foo hasBlackBox #-}
{-# ANN foo (InlineYamlPrimitive [minBound..] [__i|
 BlackBox:
   kind: Declaration
   name: Some.Incorrect.Name.bar
   template: |-
     // begin foo
     foo
     // end foo
|]) #-}

Clash will fail with a very misleading error message:

<no location info>: error:
    module ‘Some.Correct.Name’ cannot be found locally

Ultimately, this is caused by functions in LoadInterfaceFiles not propagating up their errors cleanly:

clash-compiler/clash-ghc/src-ghc/Clash/GHC/LoadInterfaceFiles.hs

Lines 405 to 461 in a8b213a

	getUnresolvedPrimitives
	:: MonadIO m
	=> HDL
	-> (Annotations.CoreAnnTarget, Primitive)
	-> m [Either UnresolvedPrimitive FilePath]
	getUnresolvedPrimitives hdl (target, prim) | hdl `elem` primHdls prim =
	case prim of
	Primitive _ fp -> pure [Right fp]
	InlineYamlPrimitive _ contentOrFp ->
	case target of
	-- Module annotation, can house many primitives
	Annotations.ModuleTarget _ ->
	liftIO (decodeOrErrYaml contentOrFp <$> BL.readFile contentOrFp)
	Annotations.NamedTarget targetName0 ->
	let targetName1 = Text.unpack (qualifiedNameString' targetName0)
	primOrErr = decodeOrErrYaml targetName1 (BLU.fromString contentOrFp)
	primName = Text.unpack (name primOrErr) in
	if primName /= targetName1
	then inlineNameError targetName1 primName
	else pure [Left primOrErr]
	InlinePrimitive _ contentOrFp ->
	case target of
	-- Module annotation, can house many primitives
	Annotations.ModuleTarget _ ->
	liftIO (decodeOrErrJson contentOrFp <$> BL.readFile contentOrFp)
	Annotations.NamedTarget targetName0 ->
	let targetName1 = Text.unpack (qualifiedNameString' targetName0)
	primOrErr =
	case decodeOrErrJson targetName1 (BLU.fromString contentOrFp) of
	[] -> error $ "No annotations found for " ++ targetName1
	++ " even though it had an InlinePrimitive annotation."
	[p] -> p
	_ -> error $ "Multiple primitive definitions found in "
	++ "InlinePrimitive annotation for " ++ targetName1 ++ ". "
	++ "Expected a single one."
	primName = Text.unpack (name primOrErr) in
	if primName /= targetName1
	then inlineNameError targetName1 primName
	else pure [Left primOrErr]
	where
	inlineNameError targetName primName =
	error $ concat
	[ "Function " ++ targetName ++ " was annotated with an inline "
	, "primitive for " ++ primName ++ ". These names "
	, "should be the same." ]
	primHdls = \case
	Primitive hdls _ -> hdls
	InlinePrimitive hdls _ -> hdls
	InlineYamlPrimitive hdls _ -> hdls
	getUnresolvedPrimitives _ _ = return []

The error Clash should have given is:

Function Some.Correct.Name.foo was annotated with an inline primitive for Some.Incorrect.Name.bar. These names should be the same.

[leonschoorl]

There is another instance of this same sort of behaviour in loadImportAndInterpret, it's like

res <- loadModule FromPackageDB ...
case res of
  Success _ -> return res
  Failed _ -> loadModule FromLocalSourceFile ...

Where clash tries to load something from the (global) package database, and if anything goes wrong it assumes that it doesn't exist there, throws away the error message and tries again to load that module from a local source file, possible failing with the confusing error that the module can't be found locally.

We should probably fix those two instances in one go.