Better support for interface types in cue get go

[myitcv]

Consider the following Go code.

package main

type Config struct {
        Steps map[string]Step
}

type Step interface {
        StepType() StepType
}

type StepType int

const (
        StepTypeCommand StepType = iota
        StepTypeUpload
)

type Command struct{}

func (c *Command) StepType() StepType { return StepTypeCommand }

var _ Step = (*Command)(nil)

type Upload struct{}

func (c *Upload) StepType() StepType { return StepTypeUpload }

var _ Step = (*Upload)(nil)

Note that the types *Command and *Upload implement the Step interface.

Running cue get go currently (as of 304b02e) produces the following:

package main

#Config: {
        Steps: {[string]: #Step} @go(,map[string]Step)
}

#Step: _

#StepType: int // #enumStepType

#enumStepType:
        #StepTypeCommand |
        #StepTypeUpload

#StepTypeCommand: #StepType & 0
#StepTypeUpload:  #StepType & 1

#Command: {
}

#Upload: {
}

Notice the Step Go interface type is converted to top (_).

This is somewhat problematic because we have lost information about the connection between Step, Command and Upload types.

Ideally #Step, #Command and #Upload would be generated as:

#Step: #Command | #Upload 

#Command: {
        StepType: #StepTypeCommand
}

#Upload: {
        StepType: #StepTypeUpload
}

It feels like something like this would be desirable.

As far as I can tell:

1. such a mode would require whole-program analysis
2. the types in the #Step definition disjunction would be limited to that whole-program analysis
3. some way of identifying a discriminator method on the source Go interface would be required (not shown in the example above)

Regarding point 3, perhaps a special directive declared on the interface type would work?

// Step is an interface
//
//cue:discriminator StepType
type Step interface {
        StepType() StepType
}

Thoughts?

[myitcv]

If you will forgive the dialogue of one...

@rogpeppe kindly exchanged a few ideas on the topic which led me to the following iteration:

exec go run main.go

-- config/config.cue --
package config

#Step: (#Command | #Upload) & {
	StepType: #StepType
}

#Command: StepType: #StepTypeCommand
#Upload: StepType:  #StepTypeUpload
-- config/config.go --
package config

import (
	"encoding/json"
)

//go:generate go run cuelang.org/go/cmd/cue get go --local

type Config struct {
	Name string
	Step Step
}

type noOpUnmarshalJSON struct{}

func (n *noOpUnmarshalJSON) UnmarshalJSON([]byte) error {
	return nil
}

func (c *Config) UnmarshalJSON(b []byte) error {
	type noUnmarshal Config
	var v struct {
		Step json.RawMessage
		*noUnmarshal
	}
	v.noUnmarshal = (*noUnmarshal)(c)
	if err := json.Unmarshal(b, &v); err != nil {
		return err
	}
	var discrim struct {
		StepType StepType
	}
	if err := json.Unmarshal(v.Step, &discrim); err != nil {
		return err
	}
	var step Step
	switch discrim.StepType {
	case StepTypeCommand:
		step = new(Command)
	case StepTypeUpload:
		step = new(Upload)
	}
	if err := json.Unmarshal(v.Step, step); err != nil {
		panic(err)
	}
	c.Step = step
	return nil
}

type Step interface {
	IsStep()
}

type StepType int

const (
	StepTypeCommand StepType = iota + 1
	StepTypeUpload
)

type Command struct {
	StepType
	Cmd string
}

func (c *Command) IsStep() {}

var _ Step = (*Command)(nil)

func (c *Command) MarshalJSON() ([]byte, error) {
	type withDiscrim struct {
		Command
		StepType StepType
	}
	type noMarshal withDiscrim
	return json.Marshal(noMarshal{
		Command:  *c,
		StepType: StepTypeCommand,
	})
}

type Upload struct {
	StepType
	Path    string
	Content string
}

func (c *Upload) IsStep() {}

var _ Step = (*Upload)(nil)

func (u *Upload) MarshalJSON() ([]byte, error) {
	type withDiscrim struct {
		Upload
		StepType StepType
	}
	type noMarshal withDiscrim
	return json.Marshal(noMarshal{
		Upload:   *u,
		StepType: StepTypeUpload,
	})
}
-- config/config_go_gen.cue --
// Code generated by cue get go. DO NOT EDIT.

//cue:generate cue get go mod.com/config

package config

#Config: _

#Step: _

#StepType: int // #enumStepType

#enumStepType:
	#StepTypeCommand |
	#StepTypeUpload

#StepTypeCommand: #StepType & 1
#StepTypeUpload:  #StepType & 2

#Command: _

#Upload: _
-- go.mod --
module mod.com

go 1.15

require (
	cuelang.org/go v0.3.0-alpha1.0.20200730155834-304b02e40842
	github.com/kr/pretty v0.1.0
)
-- main.go --
package main

import (
	"encoding/json"
	"fmt"

	"github.com/kr/pretty"
	"mod.com/config"
)

func main() {
	before := config.Config{
		Name: "hello",
		Step: &config.Upload{
			Path:    "/path/to/nowhere",
			Content: "Something in this upload",
		},
	}
	fmt.Printf("before> %v\n", pretty.Sprint(before))
	b, err := json.MarshalIndent(before, "", "  ")
	if err != nil {
		panic(err)
	}
	fmt.Printf("json > %s\n", b)

	var after config.Config
	if err := json.Unmarshal(b, &after); err != nil {
		panic(err)
	}
	fmt.Printf("after> %v\n", pretty.Sprint(after))
}
-- tools.go --
// +build tools

package tools

import (
	_ "cuelang.org/go/cmd/cue"
)

This issue here, however, being that cue get go converts types which define UnmarshalJSON et al to top (_), which isn't particularly useful for a user of our configuration types!

[cueckoo]

This discussion has been migrated to cue-lang/cue#462.

For more details about CUE's migration to a new home, please see cue-lang/cue#1078.