Tolerate funny includes

[lf-]

We use hpack, which results in having a lot of yaml.

Excerpt of such YAML:

<<: !include ../../hpack-common/defaults.yaml

name: some-package
version: 0.1.0.0
license: NONE
author: ""
maintainer: ""

flags:
  dev:
    description: "some flag"
    manual: true
    default: false
  <<: *defaultflags

This yaml is valid in hpack, where it pulls the anchor value from hpack-common/defaults.yaml, which contains:

<<: !include default-extensions.yaml
<<: !include flags.yaml
<<: !include ghc-options.yaml

And then hpack-common/flags.yaml contains:

_defaultflags: &defaultflags
  hie:
    description: Generate HIE files
    manual: true
    default: true

This whole thing is valid in the Haskell yaml parser as used by hpack and does merge all of the << together even though my language server does not like it and apparently nor does yamlfmt:

$ yamlfmt local-packages/somepackage/package.yaml
encountered the following formatting errors:
local-packages/somepackage/package.yaml: yaml: unknown anchor 'defaultflags' referenced

[braydonk]

I've never seen this !include directive before, if it is part of the actual YAML spec I'm not sure where it is. It seems like a directive for a pre-processor of some kind? The underlying YAML library will almost certainly not process these directives. As a result of that, the error would be expected; I presume the !include causes a preprocessor to merge another document into the current one like a C header which would make that anchor discoverable, but since the library yamlfmt won't do that it is an expected error to not be able to find the defaultflags anchor.

It may be feasible to implement something like this in the internal/hotfix package as a feature that can find these !include directives and shove that document into the current one like a C header, but it would be challenging to do it in a way such that the formatted output then is still the end result of just the original document with the !include directive all formatted properly.

I am not going to have time to implement something like this, but if you or someone else reading this is interested I can try to help guide an implementation if it's possible.

[lf-]

It turns out it is parsed by our underlying yaml library but it may well be that Haskell people had some quality fun inventing their own standard: https://hackage.haskell.org/package/yaml-0.11.11.2/docs/Data-Yaml-Include.html

It's not quite a C include since if there's duplicate keys defined in an include and in the file with the include, the first one is thrown out with no warning or error. This is kind of a footgun for us in our package configs which is why we use anchors.

Honestly though, the solution I would expect is to just allow ignoring unrecognized anchors and these duplicate include directives and not worry about reading other files at all. I don't expect the code formatter to implement whatever madness the Haskell people made up :)