func (cdd *CDD) results(tup *types.Tuple) (res results) {
if tup == nil {
res.typ = "void"
return
}
n := tup.Len()
res.names = make([]string, n)
for i := 0; i < n; i++ {
name := tup.At(i).Name()
switch name {
case "":
name = "_" + strconv.Itoa(n)
case "_":
res.hasNames = true
default:
name += "$"
res.hasNames = true
}
res.names[i] = name
}
if n > 1 {
res.typ, res.fields, res.acds = cdd.tupleName(tup)
return
}
v := tup.At(0)
field0 := types.NewField(v.Pos(), v.Pkg(), "_0", v.Type(), false)
res.fields = []*types.Var{field0}
res.typ, res.dim, res.acds = cdd.TypeStr(v.Type())
return
}
func (p *importer) field() *types.Var {
pkg, name := p.qualifiedName()
typ := p.typ()
anonymous := false
if name == "" {
// anonymous field - typ must be T or *T and T must be a type name
switch typ := deref(typ).(type) {
case *types.Basic: // basic types are named types
pkg = nil
name = typ.Name()
case *types.Named:
obj := typ.Obj()
name = obj.Name()
// correct the field package for anonymous fields
if exported(name) {
pkg = p.pkgList[0]
}
default:
panic("anonymous field expected")
}
anonymous = true
}
return types.NewField(token.NoPos, pkg, name, typ, anonymous)
}
// Field = Name Type [ string_lit ] .
//
func (p *parser) parseField() (*types.Var, string) {
pkg, name := p.parseName(true)
typ := p.parseType()
anonymous := false
if name == "" {
// anonymous field - typ must be T or *T and T must be a type name
switch typ := deref(typ).(type) {
case *types.Basic: // basic types are named types
pkg = nil
name = typ.Name()
case *types.Named:
name = typ.Obj().Name()
default:
p.errorf("anonymous field expected")
}
anonymous = true
}
tag := ""
if p.tok == scanner.String {
s := p.expect(scanner.String)
var err error
tag, err = strconv.Unquote(s)
if err != nil {
p.errorf("invalid struct tag %s: %s", s, err)
}
}
return types.NewField(token.NoPos, pkg, name, typ, anonymous), tag
}
// Field = Name Type [ string_lit ] .
//
func (p *parser) parseField() (*types.Var, string) {
pkg, name := p.parseName(true)
typ := p.parseType()
anonymous := false
if name == "" {
// anonymous field - typ must be T or *T and T must be a type name
switch typ := deref(typ).(type) {
case *types.Basic: // basic types are named types
pkg = nil
name = typ.Name()
case *types.Named:
obj := typ.Obj()
pkg = obj.Pkg() // TODO(gri) is this still correct?
name = obj.Name()
default:
p.errorf("anonymous field expected")
}
anonymous = true
}
tag := ""
if p.tok == scanner.String {
tag = p.expect(scanner.String)
}
return types.NewField(token.NoPos, pkg, name, typ, anonymous), tag
}
// Field = Name Type [string] .
func (p *parser) parseField(pkg *types.Package) (field *types.Var, tag string) {
name := p.parseName()
typ := p.parseType(pkg)
anon := false
if name == "" {
anon = true
switch typ := deref(typ).(type) {
case *types.Basic:
name = typ.Name()
case *types.Named:
name = typ.Obj().Name()
default:
p.error("anonymous field expected")
}
}
field = types.NewField(token.NoPos, pkg, name, typ, anon)
if p.tok == scanner.String {
tag = p.parseString()
}
return
}
func (cdd *CDD) tupleName(tup *types.Tuple) (tupName string, fields []*types.Var, acds []*CDD) {
n := tup.Len()
for i := 0; i < n; i++ {
if i != 0 {
tupName += "$$"
}
name, dim, a := cdd.TypeStr(tup.At(i).Type())
tupName += dimFuncPtr(name, dim)
acds = append(acds, a...)
}
tupName = strings.Map(symToDol, tupName)
fields = make([]*types.Var, n)
for i := 0; i < n; i++ {
v := tup.At(i)
fields[i] = types.NewField(
v.Pos(), v.Pkg(), "_"+strconv.Itoa(i), v.Type(), false,
)
}
if _, ok := cdd.gtc.tupNames[tupName]; ok {
return
}
cdd.gtc.tupNames[tupName] = struct{}{}
s := types.NewStruct(fields, nil)
o := types.NewTypeName(tup.At(0).Pos(), cdd.gtc.pkg, tupName, s)
acd := cdd.gtc.newCDD(o, TypeDecl, 0)
acd.structDecl(new(bytes.Buffer), tupName, s)
cdd.DeclUses[o] = true
acds = append(acds, acd)
return
}