@@ -19,8 +19,8 @@ import (
1919 "fmt"
2020 "go/ast"
2121 "strconv"
22- "strings"
2322
23+ "golang.org/x/tools/go/packages"
2424 "sigs.k8s.io/controller-tools/pkg/crd"
2525 "sigs.k8s.io/controller-tools/pkg/loader"
2626 "sigs.k8s.io/controller-tools/pkg/markers"
@@ -79,20 +79,21 @@ func (im importIdents) findPackagePathForSelExpr(expr *ast.SelectorExpr) (pkgPat
7979
8080 // Short-circuit if only one import.
8181 if len (imports ) == 1 {
82- return imports [0 ].path
83- }
84-
85- // If multiple files contain the same local import name, check to see which file contains the selector expression.
86- for _ , imp := range imports {
87- if imp .f .Pos () <= expr .Pos () && imp .f .End () >= expr .End () {
88- return imp .path
82+ pkgPath = imports [0 ].path
83+ } else {
84+ // If multiple files contain the same local import name, check to see which file contains the selector expression.
85+ for _ , imp := range imports {
86+ if imp .f .Pos () <= expr .Pos () && imp .f .End () >= expr .End () {
87+ pkgPath = imp .path
88+ break
89+ }
8990 }
9091 }
91- return ""
92+ return loader . NonVendorPath ( pkgPath )
9293}
9394
9495// getMarkedChildrenOfField collects all marked fields from type declarations starting at rootField in depth-first order.
95- func (g generator ) getMarkedChildrenOfField (rootPkg * loader.Package , rootField markers.FieldInfo ) (map [string ][]* fieldInfo , error ) {
96+ func (g generator ) getMarkedChildrenOfField (rootPkg * loader.Package , rootField markers.FieldInfo ) (map [crd. TypeIdent ][]* fieldInfo , error ) {
9697 // Gather all types and imports needed to build the BFS tree.
9798 rootPkg .NeedTypesInfo ()
9899 importIDs , err := newImportIdents (rootPkg )
@@ -102,50 +103,46 @@ func (g generator) getMarkedChildrenOfField(rootPkg *loader.Package, rootField m
102103
103104 // ast.Inspect will not traverse into fields, so iteratively collect them and to check for markers.
104105 nextFields := []* fieldInfo {{FieldInfo : rootField }}
105- markedFields := map [string ][]* fieldInfo {}
106+ markedFields := map [crd. TypeIdent ][]* fieldInfo {}
106107 for len (nextFields ) > 0 {
107108 fields := []* fieldInfo {}
108109 for _ , field := range nextFields {
109- errs := []error {}
110110 ast .Inspect (field .RawField , func (n ast.Node ) bool {
111111 if n == nil {
112112 return true
113113 }
114114
115- var info * markers.TypeInfo
116- var hasInfo bool
115+ var ident crd.TypeIdent
117116 switch nt := n .(type ) {
118- case * ast.SelectorExpr :
119- // Case of a type definition in an imported package.
120-
117+ case * ast.SelectorExpr : // Type definition in an imported package.
121118 pkgPath := importIDs .findPackagePathForSelExpr (nt )
122119 if pkgPath == "" {
123120 // Found no reference to pkgPath in any file.
124121 return true
125122 }
126- if pkg , hasImport := rootPkg .Imports ()[loader . NonVendorPath ( pkgPath ) ]; hasImport {
127- // Check if the field's type exists in the known types.
128- info , hasInfo = g . types [ crd.TypeIdent {Package : pkg , Name : nt .Sel .Name }]
123+ if pkg , hasImport := rootPkg .Imports ()[pkgPath ]; hasImport {
124+ pkg . NeedTypesInfo ()
125+ ident = crd.TypeIdent {Package : pkg , Name : nt .Sel .Name }
129126 }
130- case * ast.Ident :
131- // Case of a local type definition.
132-
133- // Only look at type names.
134- if nt .Obj != nil && nt .Obj .Kind == ast .Typ {
135- // Check if the field's type exists in the known types.
136- info , hasInfo = g .types [crd.TypeIdent {Package : rootPkg , Name : nt .Name }]
127+ case * ast.Ident : // Local type definition.
128+ // Only look at type idents or references to type idents in other files.
129+ if nt .Obj == nil || nt .Obj .Kind == ast .Typ {
130+ ident = crd.TypeIdent {Package : rootPkg , Name : nt .Name }
137131 }
138132 }
139- if ! hasInfo {
133+
134+ // Check if the field's type is a known types.
135+ info , hasInfo := g .types [ident ]
136+ if ident == (crd.TypeIdent {}) || ! hasInfo {
140137 return true
141138 }
142139
143140 // Add all child fields to the list to search next.
144141 for _ , finfo := range info .Fields {
145142 segment , err := getPathSegmentForField (finfo )
146143 if err != nil {
147- errs = append ( errs , fmt .Errorf ("error getting path from type %s field %s: %v" , info .Name , finfo .Name , err ))
148- return true
144+ rootPkg . AddError ( fmt .Errorf ("error getting path from type %s field %s: %v" , info .Name , finfo .Name , err ))
145+ continue
149146 }
150147 // Add extra information to the segment if it comes from a certain field type.
151148 switch finfo .RawField .Type .(type ) {
@@ -166,33 +163,19 @@ func (g generator) getMarkedChildrenOfField(rootPkg *loader.Package, rootField m
166163 fields = append (fields , f )
167164 // Marked fields get collected for the caller to parse.
168165 if len (finfo .Markers ) != 0 {
169- markedFields [info . Name ] = append (markedFields [info . Name ], f )
166+ markedFields [ident ] = append (markedFields [ident ], f )
170167 }
171168 }
172169
173170 return true
174171 })
175- if err := fmtParseErrors (errs ); err != nil {
176- return nil , err
177- }
178172 }
179173 nextFields = fields
180174 }
181- return markedFields , nil
182- }
183175
184- // fmtParseErrors prettifies a list of errors to make them easier to read.
185- func fmtParseErrors (errs []error ) error {
186- switch len (errs ) {
187- case 0 :
188- return nil
189- case 1 :
190- return errs [0 ]
176+ if loader .PrintErrors ([]* loader.Package {rootPkg }, packages .TypeError ) {
177+ return nil , errors .New ("package had type errors" )
191178 }
192- sb := strings.Builder {}
193- for _ , err := range errs {
194- sb .WriteString ("\n " )
195- sb .WriteString (err .Error ())
196- }
197- return errors .New (sb .String ())
179+
180+ return markedFields , nil
198181}
0 commit comments