func (c *converter) convertTypeName(v *gotypes.TypeName) *types.TypeName {
if v == nil {
return nil
}
if v, ok := c.converted[v]; ok {
return v.(*types.TypeName)
}
// This part is a bit tricky. gcimport calls NewTypeName with a nil typ
// argument, and then calls NewNamed on the resulting *TypeName, which
// sets its typ to a *Named referring to itself. So if we get a *TypeName
// whose Type() is a *Named whose Obj() is the same *TypeName, we know it
// was constructed this way, so we do the same. Otherwise we get into a
// infinite recursion converting the *TypeName's type.
var typ types.Type
if named, ok := v.Type().(*gotypes.Named); !ok || named.Obj() != v {
typ = c.convertType(v.Type())
}
ret := types.NewTypeName(
token.Pos(v.Pos()),
c.convertPackage(v.Pkg()),
v.Name(),
typ,
)
c.converted[v] = ret
named := types.NewNamed(ret, c.convertType(v.Type().Underlying()), nil)
c.converted[v.Type()] = named
return ret
}
func (c *converter) convertNamed(v *gotypes.Named) *types.Named {
if v == nil {
return nil
}
if v, ok := c.converted[v]; ok {
return v.(*types.Named)
}
if gotypes.Universe.Lookup("error").(*gotypes.TypeName).Type().(*gotypes.Named) == v {
return types.Universe.Lookup("error").(*types.TypeName).Type().(*types.Named)
}
typeName := c.convertTypeName(v.Obj())
ret, ok := typeName.Type().(*types.Named)
if !ok {
ret = types.NewNamed(nil, nil, nil)
}
c.converted[v] = ret
for i := 0; i < v.NumMethods(); i++ {
ret.AddMethod(c.convertFunc(v.Method(i)))
}
ret.SetUnderlying(c.convertType(v.Underlying()))
return ret
}
