generator_input.go

package chainergen

import (
	"go/types"

	"github.com/dave/jennifer/jen"
	genlib "nhatp.com/go/gen-lib"
)

type generatorInput struct {
	target     *Struct
	chainer    *chainer
	paramNames map[string]string // unique_name -> emitted_name
	usedVars   map[string]bool   // name -> is_used
}

func (i *generatorInput) isUsed(varName string) bool {
	if i.usedVars == nil {
		i.usedVars = make(map[string]bool)
		for _, s := range i.chainer.methods {
			for _, v := range s.received {
				i.usedVars[v.Name()] = false
			}

			if s.handled != "" {
				i.usedVars[s.handled] = true
			}

			for _, v := range s.passed {
				i.usedVars[v] = true
			}
		}

		for _, v := range i.chainer.returned {
			isHandled := false
			for _, s := range i.chainer.methods {
				if s.handled == v.Name() {
					isHandled = true
					break
				}
			}

			if !isHandled {
				i.usedVars[v.Name()] = true
			}
		}
	}
	return i.usedVars[varName]
}

func (i *generatorInput) paramName(uniqueName string) string {
	if i.paramNames == nil {
		i.paramNames = make(map[string]string)
		for _, v := range i.chainer.params {
			if i.target.Config.UseGeneratedParamName {
				i.paramNames[v.uniqueName] = v.uniqueName
			} else {
				i.paramNames[v.uniqueName] = v.original.Name()
			}
		}
	}

	name, have := i.paramNames[uniqueName]
	if !have {
		return uniqueName
	}
	return name
}

func (i *generatorInput) arguments() []jen.Code {
	var out []jen.Code
	for _, v := range i.chainer.params {
		out = append(out, jen.Id(i.paramName(v.uniqueName)).Add(genlib.TypeToJenCode(v.original.Type())))
	}
	return out
}

func (i *generatorInput) results() []jen.Code {
	var out []jen.Code
	for _, v := range i.chainer.results {
		out = append(out, genlib.VarToJenCode(v))
	}
	return out
}

func (i *generatorInput) returns() []jen.Code {
	var out []jen.Code
	for _, v := range i.chainer.returned {
		isHandled := false
		for _, s := range i.chainer.methods {
			if s.handled == v.Name() {
				isHandled = true
				break
			}
		}

		if isHandled {
			out = append(out, genlib.ZeroValueOfType(v.Type()))
		} else {
			out = append(out, jen.Id(v.Name()))
		}
	}
	return out
}

func (i *generatorInput) methodParams(m chainerMethod) []*types.Var {
	var out []*types.Var
	for _, v := range m.passed {
		for _, vv := range i.chainer.params {
			if vv.uniqueName != v {
				continue
			}
			out = append(out, vv.original)
		}
	}
	return out
}

func (i *generatorInput) methodReturns(m chainerMethod) []types.Type {
	var out []types.Type
	for _, v := range m.received {
		out = append(out, v.Type())
	}
	return out
}

func (i *generatorInput) methodAssignOp(m chainerMethod) string {
	for _, v := range m.received {
		if i.isUsed(v.Name()) {
			return ":="
		}
	}
	return "="
}

func (i *generatorInput) methodReceivedVars(m chainerMethod) []string {
	var out []string
	for _, v := range m.received {
		if i.isUsed(v.Name()) {
			out = append(out, v.Name())
		} else {
			out = append(out, "_")
		}
	}
	return out
}

func (i *generatorInput) methodReceived(m chainerMethod) []jen.Code {
	var out []jen.Code
	for _, v := range m.received {
		if i.isUsed(v.Name()) {
			out = append(out, jen.Id(v.Name()))
		} else {
			out = append(out, jen.Id("_"))
		}
	}
	return out
}

func (i *generatorInput) methodArguments(m chainerMethod) []jen.Code {
	var out []jen.Code
	for _, v := range m.passed {
		out = append(out, jen.Id(i.paramName(v)))
	}
	return out
}

func (i *generatorInput) handleErrorReturns() []jen.Code {
	var out []jen.Code
	for j, r := range i.chainer.returned {
		if j != len(i.chainer.returned)-1 {
			typ := genlib.ZeroValueOfType(r.Type())
			out = append(out, typ)
		}
	}
	return out
}