12858520582

Committed 20 Jan 2025 12:21AM CUT coverage: 56.633% (-0.8%) from 57.418%

Build # 12858520582

Build Type

Pull #73

github

Committed by

web-flow

Commit Message

Merge 76145dc26 into ef546a39d

Pull Request Pull Request #73: Fix cross-refs to package and module aliases

Run Details

8 of 34 new or added lines in 7 files covered. (23.53%)

2 existing lines in 2 files now uncovered.

841 of 1485 relevant lines covered (56.63%)

8.1 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.1

/document/filter.go

package document

import (
        "fmt"
        "strings"
)

// Filters and re-structures docs for package re-exports.
//
// Also collects a lookup, mapping from original to altered cross-refs.
func (proc *Processor) filterPackages() error {
        proc.linkExports = map[string]string{}
        proc.linkExportsReverse = map[string]*exportError{}
        anyExports, err := proc.collectExports(proc.Docs.Decl, nil)
        if err != nil {
                return err
        }

        if !proc.Config.UseExports {
                proc.ExportDocs = &Docs{
                        Version: proc.Docs.Version,
                        Decl:    proc.Docs.Decl,
                }
                return nil
        }

        if !anyExports {
                return fmt.Errorf("no package re-exports found. Given flag '--exports', there will be no output.\n       Add exports or run without flag '--exports'")
        }

        proc.ExportDocs = &Docs{
                Version: proc.Docs.Version,
                Decl:    proc.Docs.Decl.linkedCopy(),
        }
        proc.addLinkExport([]string{proc.Docs.Decl.Name}, []string{proc.Docs.Decl.Name})
        proc.filterPackage(proc.Docs.Decl, proc.ExportDocs.Decl, nil, nil)

        errs := []*exportError{}
        for _, expErr := range proc.linkExportsReverse {
                if len(expErr.OldPaths) > 1 {
                        errs = append(errs, expErr)
                }
        }
        if len(errs) == 0 {
                return nil
        }
        msg := strings.Builder{}
        msg.WriteString(fmt.Sprintln("Name collisions in package re-exports:"))
        for _, expErr := range errs {
                msg.WriteString(fmt.Sprintf(" - %s (", expErr.NewPath))
                for i, pOld := range expErr.OldPaths {
                        if i > 0 {
                                msg.WriteString(", ")
                        }
                        msg.WriteString(pOld)
                }
                msg.WriteString(")\n")
        }

        return fmt.Errorf("%s", msg.String())
}

type exportError struct {
        NewPath  string
        OldPaths []string
}

func (proc *Processor) filterPackage(src, rootOut *Package, oldPath, newPath []string) {
        rootExports := map[string]*members{}
        collectExportsPackage(src, rootExports)

        oldPath = appendNew(oldPath, src.Name)
        newPath = appendNew(newPath, src.Name)

        for _, mod := range src.Modules {
                if mems, ok := rootExports[mod.Name]; ok {
                        proc.collectModuleExports(mod, rootOut, oldPath, newPath, mems)
                }
        }

        for _, pkg := range src.Packages {
                if mems, ok := rootExports[pkg.Name]; ok {
                        proc.collectPackageExports(pkg, rootOut, oldPath, newPath, mems)
                }
        }
}

func (proc *Processor) collectPackageExports(src, rootOut *Package, oldPath, newPath []string, rootMembers *members) {
        selfIncluded, toCrawl := collectExportMembers(rootMembers)

        if selfIncluded {
                newPkg := src.linkedCopy()
                proc.filterPackage(src, newPkg, oldPath, newPath)
                rootOut.Packages = append(rootOut.Packages, newPkg)

                tempOldPath := appendNew(oldPath, src.Name)
                tempNewPath := appendNew(newPath, src.Name)
                proc.addLinkExport(tempOldPath, tempNewPath)
        }
        oldPath = appendNew(oldPath, src.Name)

        for _, mod := range src.Modules {
                if mems, ok := toCrawl[mod.Name]; ok {
                        proc.collectModuleExports(mod, rootOut, oldPath, newPath, mems)
                }
        }

        for _, pkg := range src.Packages {
                if mems, ok := toCrawl[pkg.Name]; ok {
                        proc.collectPackageExports(pkg, rootOut, oldPath, newPath, mems)
                }
        }

        for _, elem := range src.Aliases {
                proc.collectExportsAlias(elem, oldPath, newPath)
        }
        for _, elem := range src.Structs {
                proc.collectExportsStruct(elem, oldPath, newPath)
        }
        for _, elem := range src.Traits {
                proc.collectExportsTrait(elem, oldPath, newPath)
        }
        for _, elem := range src.Functions {
                proc.collectExportsFunction(elem, oldPath, newPath)
        }
}

func (proc *Processor) collectModuleExports(src *Module, rootOut *Package, oldPath, newPath []string, rootMembers *members) {
        selfIncluded, toCrawl := collectExportMembers(rootMembers)

        oldPath = appendNew(oldPath, src.Name)
        if selfIncluded {
                rootOut.Modules = append(rootOut.Modules, src)

                tempNewPath := appendNew(newPath, src.Name)
                proc.addLinkExport(oldPath, tempNewPath)

                collectExportsList(proc, src.Aliases, oldPath, tempNewPath)
                for _, elem := range src.Structs {
                        proc.collectExportsStruct(elem, oldPath, tempNewPath)
                }
                for _, elem := range src.Traits {
                        proc.collectExportsTrait(elem, oldPath, tempNewPath)
                }
                for _, elem := range src.Functions {
                        proc.collectExportsFunction(elem, oldPath, tempNewPath)
                }
        }

        for _, elem := range src.Aliases {
                if _, ok := toCrawl[elem.Name]; ok {
                        rootOut.Aliases = append(rootOut.Aliases, elem)
                        proc.collectExportsAlias(elem, oldPath, newPath)
                }
        }
        for _, elem := range src.Structs {
                if _, ok := toCrawl[elem.Name]; ok {
                        rootOut.Structs = append(rootOut.Structs, elem)
                        proc.collectExportsStruct(elem, oldPath, newPath)
                }
        }
        for _, elem := range src.Traits {
                if _, ok := toCrawl[elem.Name]; ok {
                        rootOut.Traits = append(rootOut.Traits, elem)
                        proc.collectExportsTrait(elem, oldPath, newPath)
                }
        }
        for _, elem := range src.Functions {
                if _, ok := toCrawl[elem.Name]; ok {
                        rootOut.Functions = append(rootOut.Functions, elem)
                        proc.collectExportsFunction(elem, oldPath, newPath)
                }
        }
}

func (proc *Processor) collectExportsStruct(s *Struct, oldPath []string, newPath []string) {
        oldPath = appendNew(oldPath, s.Name)
        newPath = appendNew(newPath, s.Name)

        proc.addLinkExport(oldPath, newPath)

        collectExportsList(proc, s.Aliases, oldPath, newPath)
        collectExportsList(proc, s.Parameters, oldPath, newPath)
        collectExportsList(proc, s.Fields, oldPath, newPath)
        collectExportsList(proc, s.Functions, oldPath, newPath)
}

func (proc *Processor) collectExportsAlias(a *Alias, oldPath []string, newPath []string) {
        oldPath = appendNew(oldPath, a.Name)
        newPath = appendNew(newPath, a.Name)

        proc.addLinkExport(oldPath, newPath)
}

func (proc *Processor) collectExportsTrait(s *Trait, oldPath []string, newPath []string) {
        oldPath = appendNew(oldPath, s.Name)
        newPath = appendNew(newPath, s.Name)

        proc.addLinkExport(oldPath, newPath)

        collectExportsList(proc, s.Fields, oldPath, newPath)
        collectExportsList(proc, s.Functions, oldPath, newPath)
}

func (proc *Processor) collectExportsFunction(s *Function, oldPath []string, newPath []string) {
        oldPath = appendNew(oldPath, s.Name)
        newPath = appendNew(newPath, s.Name)

        proc.addLinkExport(oldPath, newPath)
}

func collectExportsList[T Named](proc *Processor, sl []T, oldPath, newPath []string) {
        for _, elem := range sl {
                oldPath := appendNew(oldPath, elem.GetName())
                newPath := appendNew(newPath, elem.GetName())
                proc.addLinkExport(oldPath, newPath)
        }
}

type members struct {
        Members []member
}

type member struct {
        Include bool
        RelPath []string
}

func collectExportMembers(parentMember *members) (selfIncluded bool, toCrawl map[string]*members) {
        selfIncluded = false
        toCrawl = map[string]*members{}

        for _, mem := range parentMember.Members {
                if mem.Include {
                        selfIncluded = true
                        continue
                }
                var newMember member
                if len(mem.RelPath) == 1 {
                        newMember = member{Include: true}
                } else {
                        newMember = member{RelPath: mem.RelPath[1:]}
                }
                if members, ok := toCrawl[mem.RelPath[0]]; ok {
                        members.Members = append(members.Members, newMember)
                        continue
                }
                toCrawl[mem.RelPath[0]] = &members{Members: []member{newMember}}
        }

        return
}

func collectExportsPackage(p *Package, out map[string]*members) {
        for _, ex := range p.exports {
                var newMember member
                if len(ex.Short) == 1 {
                        newMember = member{Include: true}
                } else {
                        newMember = member{RelPath: ex.Short[1:]}
                }
                if members, ok := out[ex.Short[0]]; ok {
                        members.Members = append(members.Members, newMember)
                        continue
                }
                out[ex.Short[0]] = &members{Members: []member{newMember}}
        }
}

1	package document
2
3	import (
4	"fmt"
5	"strings"
6	)
7
8	// Filters and re-structures docs for package re-exports.
9	//
10	// Also collects a lookup, mapping from original to altered cross-refs.
11	func (proc *Processor) filterPackages() error {	6✔
12	proc.linkExports = map[string]string{}	6✔
13	proc.linkExportsReverse = map[string]*exportError{}	6✔
14	anyExports, err := proc.collectExports(proc.Docs.Decl, nil)	6✔
15	if err != nil {	6✔
16	return err	×
17	}	×
18
19	if !proc.Config.UseExports {	9✔
20	proc.ExportDocs = &Docs{	3✔
21	Version: proc.Docs.Version,	3✔
22	Decl: proc.Docs.Decl,	3✔
23	}	3✔
24	return nil	3✔
25	}	3✔
26
27	if !anyExports {	3✔
28	return fmt.Errorf("no package re-exports found. Given flag '--exports', there will be no output.\n Add exports or run without flag '--exports'")	×
29	}	×
30
31	proc.ExportDocs = &Docs{	3✔
32	Version: proc.Docs.Version,	3✔
33	Decl: proc.Docs.Decl.linkedCopy(),	3✔
34	}	3✔
35	proc.addLinkExport([]string{proc.Docs.Decl.Name}, []string{proc.Docs.Decl.Name})	3✔
36	proc.filterPackage(proc.Docs.Decl, proc.ExportDocs.Decl, nil, nil)	3✔
37		3✔
38	errs := []*exportError{}	3✔
39	for _, expErr := range proc.linkExportsReverse {	31✔
40	if len(expErr.OldPaths) > 1 {	28✔
41	errs = append(errs, expErr)	×
42	}	×
43	}
44	if len(errs) == 0 {	6✔
45	return nil	3✔
46	}	3✔
47	msg := strings.Builder{}	×
48	msg.WriteString(fmt.Sprintln("Name collisions in package re-exports:"))	×
49	for _, expErr := range errs {	×
50	msg.WriteString(fmt.Sprintf(" - %s (", expErr.NewPath))	×
51	for i, pOld := range expErr.OldPaths {	×
52	if i > 0 {	×
53	msg.WriteString(", ")	×
54	}	×
55	msg.WriteString(pOld)	×
56	}
57	msg.WriteString(")\n")	×
58	}
59
60	return fmt.Errorf("%s", msg.String())	×
61	}
62
63	type exportError struct {
64	NewPath string
65	OldPaths []string
66	}
67
68	func (proc Processor) filterPackage(src, rootOut Package, oldPath, newPath []string) {	5✔
69	rootExports := map[string]*members{}	5✔
70	collectExportsPackage(src, rootExports)	5✔
71		5✔
72	oldPath = appendNew(oldPath, src.Name)	5✔
73	newPath = appendNew(newPath, src.Name)	5✔
74		5✔
75	for _, mod := range src.Modules {	13✔
76	if mems, ok := rootExports[mod.Name]; ok {	16✔
77	proc.collectModuleExports(mod, rootOut, oldPath, newPath, mems)	8✔
78	}	8✔
79	}
80
81	for _, pkg := range src.Packages {	7✔
82	if mems, ok := rootExports[pkg.Name]; ok {	4✔
83	proc.collectPackageExports(pkg, rootOut, oldPath, newPath, mems)	2✔
84	}	2✔
85	}
86	}
87
88	func (proc Processor) collectPackageExports(src, rootOut Package, oldPath, newPath []string, rootMembers *members) {	2✔
89	selfIncluded, toCrawl := collectExportMembers(rootMembers)	2✔
90		2✔
91	if selfIncluded {	4✔
92	newPkg := src.linkedCopy()	2✔
93	proc.filterPackage(src, newPkg, oldPath, newPath)	2✔
94	rootOut.Packages = append(rootOut.Packages, newPkg)	2✔
95		2✔
96	tempOldPath := appendNew(oldPath, src.Name)	2✔
97	tempNewPath := appendNew(newPath, src.Name)	2✔
98	proc.addLinkExport(tempOldPath, tempNewPath)	2✔
99	}	2✔
100	oldPath = appendNew(oldPath, src.Name)	2✔
101		2✔
102	for _, mod := range src.Modules {	4✔
103	if mems, ok := toCrawl[mod.Name]; ok {	4✔
104	proc.collectModuleExports(mod, rootOut, oldPath, newPath, mems)	2✔
105	}	2✔
106	}
107
108	for _, pkg := range src.Packages {	2✔
109	if mems, ok := toCrawl[pkg.Name]; ok {	×
110	proc.collectPackageExports(pkg, rootOut, oldPath, newPath, mems)	×
111	}	×
112	}
113
114	for _, elem := range src.Aliases {	2✔
NEW 115	proc.collectExportsAlias(elem, oldPath, newPath)	×
NEW 116	}	×
117	for _, elem := range src.Structs {	2✔
118	proc.collectExportsStruct(elem, oldPath, newPath)	×
119	}	×
120	for _, elem := range src.Traits {	2✔
121	proc.collectExportsTrait(elem, oldPath, newPath)	×
122	}	×
123	for _, elem := range src.Functions {	2✔
124	proc.collectExportsFunction(elem, oldPath, newPath)	×
125	}	×
126	}
127
128	func (proc Processor) collectModuleExports(src Module, rootOut Package, oldPath, newPath []string, rootMembers members) {	10✔
129	selfIncluded, toCrawl := collectExportMembers(rootMembers)	10✔
130		10✔
131	oldPath = appendNew(oldPath, src.Name)	10✔
132	if selfIncluded {	15✔
133	rootOut.Modules = append(rootOut.Modules, src)	5✔
134		5✔
135	tempNewPath := appendNew(newPath, src.Name)	5✔
136	proc.addLinkExport(oldPath, tempNewPath)	5✔
137		5✔
138	collectExportsList(proc, src.Aliases, oldPath, tempNewPath)	5✔
139	for _, elem := range src.Structs {	10✔
140	proc.collectExportsStruct(elem, oldPath, tempNewPath)	5✔
141	}	5✔
142	for _, elem := range src.Traits {	6✔
143	proc.collectExportsTrait(elem, oldPath, tempNewPath)	1✔
144	}	1✔
145	for _, elem := range src.Functions {	6✔
146	proc.collectExportsFunction(elem, oldPath, tempNewPath)	1✔
147	}	1✔
148	}
149
150	for _, elem := range src.Aliases {	11✔
151	if _, ok := toCrawl[elem.Name]; ok {	1✔
NEW 152	rootOut.Aliases = append(rootOut.Aliases, elem)	×
NEW 153	proc.collectExportsAlias(elem, oldPath, newPath)	×
NEW 154	}	×
155	}
156	for _, elem := range src.Structs {	22✔
157	if _, ok := toCrawl[elem.Name]; ok {	19✔
158	rootOut.Structs = append(rootOut.Structs, elem)	7✔
159	proc.collectExportsStruct(elem, oldPath, newPath)	7✔
160	}	7✔
161	}
162	for _, elem := range src.Traits {	13✔
163	if _, ok := toCrawl[elem.Name]; ok {	3✔
164	rootOut.Traits = append(rootOut.Traits, elem)	×
165	proc.collectExportsTrait(elem, oldPath, newPath)	×
166	}	×
167	}
168	for _, elem := range src.Functions {	13✔
169	if _, ok := toCrawl[elem.Name]; ok {	5✔
170	rootOut.Functions = append(rootOut.Functions, elem)	2✔
171	proc.collectExportsFunction(elem, oldPath, newPath)	2✔
172	}	2✔
173	}
174	}
175
176	func (proc Processor) collectExportsStruct(s Struct, oldPath []string, newPath []string) {	12✔
177	oldPath = appendNew(oldPath, s.Name)	12✔
178	newPath = appendNew(newPath, s.Name)	12✔
179		12✔
180	proc.addLinkExport(oldPath, newPath)	12✔
181		12✔
182	collectExportsList(proc, s.Aliases, oldPath, newPath)	12✔
183	collectExportsList(proc, s.Parameters, oldPath, newPath)	12✔
184	collectExportsList(proc, s.Fields, oldPath, newPath)	12✔
185	collectExportsList(proc, s.Functions, oldPath, newPath)	12✔
186	}	12✔
187
NEW 188	func (proc Processor) collectExportsAlias(a Alias, oldPath []string, newPath []string) {	×
NEW 189	oldPath = appendNew(oldPath, a.Name)	×
NEW 190	newPath = appendNew(newPath, a.Name)	×
NEW 191		×
NEW 192	proc.addLinkExport(oldPath, newPath)	×
NEW 193	}	×
194
195	func (proc Processor) collectExportsTrait(s Trait, oldPath []string, newPath []string) {	1✔
196	oldPath = appendNew(oldPath, s.Name)	1✔
197	newPath = appendNew(newPath, s.Name)	1✔
198		1✔
199	proc.addLinkExport(oldPath, newPath)	1✔
200		1✔
201	collectExportsList(proc, s.Fields, oldPath, newPath)	1✔
202	collectExportsList(proc, s.Functions, oldPath, newPath)	1✔
203	}	1✔
204
205	func (proc Processor) collectExportsFunction(s Function, oldPath []string, newPath []string) {	3✔
206	oldPath = appendNew(oldPath, s.Name)	3✔
207	newPath = appendNew(newPath, s.Name)	3✔
208		3✔
209	proc.addLinkExport(oldPath, newPath)	3✔
210	}	3✔
211
212	func collectExportsList[T Named](proc *Processor, sl []T, oldPath, newPath []string) {	55✔
213	for _, elem := range sl {	57✔
214	oldPath := appendNew(oldPath, elem.GetName())	2✔
215	newPath := appendNew(newPath, elem.GetName())	2✔
216	proc.addLinkExport(oldPath, newPath)	2✔
217	}	2✔
218	}
219
220	type members struct {
221	Members []member
222	}
223
224	type member struct {
225	Include bool
226	RelPath []string
227	}
228
229	func collectExportMembers(parentMember members) (selfIncluded bool, toCrawl map[string]members) {	12✔
230	selfIncluded = false	12✔
231	toCrawl = map[string]*members{}	12✔
232		12✔
233	for _, mem := range parentMember.Members {	32✔
234	if mem.Include {	27✔
235	selfIncluded = true	7✔
236	continue	7✔
237	}
238	var newMember member	13✔
239	if len(mem.RelPath) == 1 {	24✔
240	newMember = member{Include: true}	11✔
241	} else {	13✔
242	newMember = member{RelPath: mem.RelPath[1:]}	2✔
243	}	2✔
244	if members, ok := toCrawl[mem.RelPath[0]]; ok {	15✔
245	members.Members = append(members.Members, newMember)	2✔
246	continue	2✔
247	}
248	toCrawl[mem.RelPath[0]] = &members{Members: []member{newMember}}	11✔
249	}
250
251	return	12✔
252	}
253
254	func collectExportsPackage(p Package, out map[string]members) {	5✔
255	for _, ex := range p.exports {	21✔
256	var newMember member	16✔
257	if len(ex.Short) == 1 {	21✔
258	newMember = member{Include: true}	5✔
259	} else {	16✔
260	newMember = member{RelPath: ex.Short[1:]}	11✔
261	}	11✔
262	if members, ok := out[ex.Short[0]]; ok {	22✔
263	members.Members = append(members.Members, newMember)	6✔
264	continue	6✔
265	}
266	out[ex.Short[0]] = &members{Members: []member{newMember}}	10✔
267	}
268	}

mlange-42 / modo / 12858520582

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous