Read then write symbols as symbols, rather than special structs

[johnpyp]

My goal is to write a simple cli that takes in a binary ion file that uses a shared symbol table, provide that symbol table, then output that "hydrated" ion to a pretty printed text file.

Unexpectedly, what happens is that all the symbols in the input ion get output as "symbol structs". I see some mention of them in the documentation, but I'm not very clear on how to handle them or turn them off when I'm doing this relatively transparent reading/writing.

Here's an example of the output:

...
			my_list: [
				{
					Text: "MySymbolValue",
					LocalSID: 396,
					Source: null
				},
				{
					Text: "MySymbolValueTwo",
					LocalSID: 1414,
					Source: null
				},
...

and what'd I'd expect:

my_list: [ 'MySymbolValue', 'MySymvolValueTwo' ]

symbol annotations also get erased from structs during the conversion.

Is there any way to make this work? Am I using the wrong decoding or unmarshalling / marshalling methods or something?

I also tried just writing to the writer directly without using a "root container", and that didn't seem to have an effect.

---

Here's the code for my poc, minus the getSharedSymbolTable func in another file that isn't really relevant:

package main

import (
	"bytes"
	"flag"
	"fmt"
	"os"
	"path"

	"github.com/amazon-ion/ion-go/ion"
)

type container struct {
	Root []interface{} `ion:"root"`
}

func main() {
	opts := getOpts()

	if opts.OutputFile == "" {
		fmt.Fprintln(os.Stderr, "missing required flag --output")
		os.Exit(1)
		return
	}

	sst := getSharedSymbolTable()
	cat := ion.NewCatalog(sst)

	reader := ion.NewReaderCat(os.Stdin, cat)
	dec := ion.NewDecoder(reader)
	buf := bytes.Buffer{}
	writer := ion.NewTextWriterOpts(&buf, ion.TextWriterPretty)
	enc := ion.NewEncoder(writer)

	container := container{
		Root: make([]interface{}, 0),
	}

	for {
		val, err := dec.Decode()
		if err == ion.ErrNoInput {
			break
		} else if err != nil {
			panic(err)
		}
		container.Root = append(container.Root, val)
	}

	if err := enc.Encode(container); err != nil {
		panic(err)
	}

	if err := enc.Finish(); err != nil {
		panic(err)
	}

	p := path.Clean(opts.OutputFile)

	os.WriteFile(p, buf.Bytes(), 0644)

	fmt.Println("Wrote converted ion to", p)

}

type Opts struct {
	OutputFile string
}

func getOpts() Opts {
	var outputFile string

	flag.StringVar(&outputFile, "output", "", "Relative or absolute path to an output file")

	flag.Parse()

	return Opts{
		OutputFile: outputFile,
	}
}