// TestDevendorizeImportPaths checks if vendored // import paths are devendorized correctly. func TestDevendorizeImportPaths(t *testing.T) { i := imports.New("github.com/ernesto-jimenez/gogen/imports") pkg := types.NewPackage("github.com/ernesto-jimenez/gogen/vendor/github.com/stretchr/testify/mock", "mock") named := types.NewNamed(types.NewTypeName(token.Pos(0), pkg, "", &types.Array{}), &types.Array{}, nil) i.AddImportsFrom(named) require.Equal(t, map[string]string{"github.com/stretchr/testify/mock": "mock"}, i.Imports()) }
// Imports returns all the packages that have to be imported for the func (g Generator) Imports() map[string]string { imports := imports.New(g.Package()) for _, m := range g.Methods() { s := m.signature() imports.AddImportsFrom(s.Params()) imports.AddImportsFrom(s.Results()) } return imports.Imports() }
func (g Generator) Imports() map[string]string { imports := imports.New(g.Package()) fields := g.Fields() for i := 0; i < len(fields); i++ { m := fields[i] imports.AddImportsFrom(m.v.Type()) imports.AddImportsFrom(m.UnderlyingType()) if sub := m.UnderlyingTarget(); sub != nil { fields = append(fields, sub.Fields()...) } } return imports.Imports() }
func analyzeCode(scope *types.Scope, docs *doc.Package, variable string) (imports.Importer, []fn, error) { pkg := docs.Name v, ok := scope.Lookup(variable).(*types.Var) if v == nil { return nil, nil, fmt.Errorf("impossible to find variable %s", variable) } if !ok { return nil, nil, fmt.Errorf("%s must be a variable", variable) } var vType interface { NumMethods() int Method(int) *types.Func } switch t := v.Type().(type) { case *types.Interface: vType = t case *types.Pointer: vType = t.Elem().(*types.Named) case *types.Named: vType = t if t, ok := t.Underlying().(*types.Interface); ok { vType = t } default: return nil, nil, fmt.Errorf("variable is of an invalid type: %T", v.Type().Underlying()) } importer := imports.New(pkg) var funcs []fn for i := 0; i < vType.NumMethods(); i++ { f := vType.Method(i) if !f.Exported() { continue } sig := f.Type().(*types.Signature) funcs = append(funcs, fn{ WrappedVar: variable, Name: f.Name(), CurrentPkg: pkg, TypeInfo: f, }) importer.AddImportsFrom(sig.Params()) importer.AddImportsFrom(sig.Results()) } return importer, funcs, nil }
// analyzeCode takes the types scope and the docs and returns the import // information and information about all the assertion functions. func analyzeCode(scope *types.Scope, docs *doc.Package) (imports.Importer, []testFunc, error) { testingT := scope.Lookup("TestingT").Type().Underlying().(*types.Interface) importer := imports.New(*outputPkg) var funcs []testFunc // Go through all the top level functions for _, fdocs := range docs.Funcs { // Find the function obj := scope.Lookup(fdocs.Name) fn, ok := obj.(*types.Func) if !ok { continue } // Check function signatuer has at least two arguments sig := fn.Type().(*types.Signature) if sig.Params().Len() < 2 { continue } // Check first argument is of type testingT first, ok := sig.Params().At(0).Type().(*types.Named) if !ok { continue } firstType, ok := first.Underlying().(*types.Interface) if !ok { continue } if !types.Implements(firstType, testingT) { continue } funcs = append(funcs, testFunc{*outputPkg, fdocs, fn}) importer.AddImportsFrom(sig.Params()) } return importer, funcs, nil }