14250580349

Committed 03 Apr 2025 06:52PM CUT coverage: 74.237%. Remained the same

Build # 14250580349

Build Type

Pull #233

github

Committed by

web-flow

Commit Message

Merge 6642a250c into 1f8e6af6a

Pull Request Pull Request #233: Don't warn on missing docs for `self` arguments

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

2383 of 3210 relevant lines covered (74.24%)

48.18 hits per line

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

61.02

/internal/document/transclude.go

package document

import (
        "fmt"
        "strings"
)

func (proc *Processor) processTranscludes(docs *Docs) error {
        return proc.replaceTranscludesPackage(docs.Decl, []string{})
}

func (proc *Processor) replaceTranscludesPackage(p *Package, elems []string) error {
        newElems := appendNew(elems, p.Name)
        for _, pkg := range p.Packages {
                if err := proc.replaceTranscludesPackage(pkg, newElems); err != nil {
                        return err
                }
        }
        for _, mod := range p.Modules {
                if err := proc.replaceTranscludesModule(mod, newElems); err != nil {
                        return err
                }
        }
        return nil
}

func (proc *Processor) replaceTranscludesModule(m *Module, elems []string) error {
        newElems := appendNew(elems, m.Name)
        for _, s := range m.Structs {
                structElems := appendNew(newElems, s.Name)
                for _, f := range s.Functions {
                        if len(f.Overloads) == 0 {
                                if err := proc.replaceTranscludes(f, structElems, len(newElems)); err != nil {
                                        return err
                                }
                        } else {
                                for _, o := range f.Overloads {
                                        if err := proc.replaceTranscludes(o, structElems, len(newElems)); err != nil {
                                                return err
                                        }
                                }
                        }
                }

        }
        return nil
}

func (proc *Processor) replaceTranscludes(elem *Function, elems []string, modElems int) error {
        indices, err := findLinks(elem.Summary, transcludeRegex, false)
        if err != nil {
                return err
        }
        if len(indices) == 0 {
                return nil
        }
        if len(indices) > 2 {
                return fmt.Errorf("multiple doc transclusions in %s", strings.Join(elems, "."))
        }
        start, end := indices[0], indices[1]
        link := elem.Summary[start+1 : end-1]

        content, ok, err := proc.refToPlaceholder(link, elems, modElems, false)
        if err != nil {
                return err
        }
        if !ok {
                return nil
        }

        from, ok := proc.allPaths[content]
        if !ok {
                return fmt.Errorf("doc transclusions source %s (%s) in %s not found", link, content, strings.Join(elems, "."))
        }
        trait, ok := from.(*Trait)
        if !ok {
                return fmt.Errorf("doc transclusions source %s (%s) in %s is not a trait", link, content, strings.Join(elems, "."))
        }

        sourceFunc, ok := findImplementedFunction(elem, trait)
        if !ok {
                return fmt.Errorf("no matching doc transclusion found for %s.%s in %s. Required signature: %s", link, elem.Name, strings.Join(elems, "."), elem.Signature)
        }

        elem.MemberSummary = sourceFunc.MemberSummary
        elem.Description = sourceFunc.Description
        elem.ReturnsDoc = sourceFunc.ReturnsDoc
        elem.RaisesDoc = sourceFunc.RaisesDoc

        for i, arg := range sourceFunc.Args {
                elem.Args[i].Description = arg.Description
        }
        for i, par := range sourceFunc.Parameters {
                elem.Parameters[i].Description = par.Description
        }

        return nil
}

func findImplementedFunction(structFunc *Function, trait *Trait) (*Function, bool) {
        var sourceFunc *Function
        for _, f := range trait.Functions {
                if f.Name != structFunc.Name {
                        continue
                }
                if len(f.Overloads) == 0 {
                        if functionsMatch(structFunc, f) {
                                sourceFunc = f
                        }
                        break
                }
                for _, o := range f.Overloads {
                        if functionsMatch(structFunc, o) {
                                sourceFunc = o
                                break
                        }
                }
                break
        }
        return sourceFunc, sourceFunc != nil
}

func functionsMatch(s, t *Function) bool {
        if len(s.Args) != len(t.Args) {
                return false
        }
        if len(s.Parameters) != len(t.Parameters) {
                return false
        }

        for i := range s.Args {
                argS, argT := s.Args[i], t.Args[i]
                if argS.Type != argT.Type {
                        if !(argS.Type == "Self" && argT.Type == "_Self") {
                                return false
                        }
                }
                if argS.PassingKind != argT.PassingKind {
                        return false
                }
                if argS.Convention != argT.Convention {
                        return false
                }
        }

        for i := range s.Parameters {
                parS, parT := s.Parameters[i], t.Parameters[i]
                if parS.Type != parT.Type {
                        return false
                }
                if parS.PassingKind != parT.PassingKind {
                        return false
                }
        }

        return true
}

1	package document
2
3	import (
4	"fmt"
5	"strings"
6	)
7
8	func (proc Processor) processTranscludes(docs Docs) error {	9✔
9	return proc.replaceTranscludesPackage(docs.Decl, []string{})	9✔
10	}	9✔
11
12	func (proc Processor) replaceTranscludesPackage(p Package, elems []string) error {	14✔
13	newElems := appendNew(elems, p.Name)	14✔
14	for _, pkg := range p.Packages {	19✔
15	if err := proc.replaceTranscludesPackage(pkg, newElems); err != nil {	5✔
16	return err	×
17	}	×
18	}
19	for _, mod := range p.Modules {	34✔
20	if err := proc.replaceTranscludesModule(mod, newElems); err != nil {	20✔
21	return err	×
22	}	×
23	}
24	return nil	14✔
25	}
26
27	func (proc Processor) replaceTranscludesModule(m Module, elems []string) error {	20✔
28	newElems := appendNew(elems, m.Name)	20✔
29	for _, s := range m.Structs {	38✔
30	structElems := appendNew(newElems, s.Name)	18✔
31	for _, f := range s.Functions {	39✔
32	if len(f.Overloads) == 0 {	21✔
33	if err := proc.replaceTranscludes(f, structElems, len(newElems)); err != nil {	×
34	return err	×
35	}	×
36	} else {	21✔
37	for _, o := range f.Overloads {	42✔
38	if err := proc.replaceTranscludes(o, structElems, len(newElems)); err != nil {	21✔
39	return err	×
40	}	×
41	}
42	}
43	}
44
45	}
46	return nil	20✔
47	}
48
49	func (proc Processor) replaceTranscludes(elem Function, elems []string, modElems int) error {	21✔
50	indices, err := findLinks(elem.Summary, transcludeRegex, false)	21✔
51	if err != nil {	21✔
52	return err	×
53	}	×
54	if len(indices) == 0 {	37✔
55	return nil	16✔
56	}	16✔
57	if len(indices) > 2 {	5✔
58	return fmt.Errorf("multiple doc transclusions in %s", strings.Join(elems, "."))	×
59	}	×
60	start, end := indices[0], indices[1]	5✔
61	link := elem.Summary[start+1 : end-1]	5✔
62		5✔
63	content, ok, err := proc.refToPlaceholder(link, elems, modElems, false)	5✔
64	if err != nil {	5✔
65	return err	×
66	}	×
67	if !ok {	5✔
68	return nil	×
69	}	×
70
71	from, ok := proc.allPaths[content]	5✔
72	if !ok {	5✔
73	return fmt.Errorf("doc transclusions source %s (%s) in %s not found", link, content, strings.Join(elems, "."))	×
74	}	×
75	trait, ok := from.(*Trait)	5✔
76	if !ok {	5✔
77	return fmt.Errorf("doc transclusions source %s (%s) in %s is not a trait", link, content, strings.Join(elems, "."))	×
78	}	×
79
80	sourceFunc, ok := findImplementedFunction(elem, trait)	5✔
81	if !ok {	5✔
82	return fmt.Errorf("no matching doc transclusion found for %s.%s in %s. Required signature: %s", link, elem.Name, strings.Join(elems, "."), elem.Signature)	×
83	}	×
84
85	elem.MemberSummary = sourceFunc.MemberSummary	5✔
86	elem.Description = sourceFunc.Description	5✔
87	elem.ReturnsDoc = sourceFunc.ReturnsDoc	5✔
88	elem.RaisesDoc = sourceFunc.RaisesDoc	5✔
89		5✔
90	for i, arg := range sourceFunc.Args {	15✔
91	elem.Args[i].Description = arg.Description	10✔
92	}	10✔
93	for i, par := range sourceFunc.Parameters {	5✔
94	elem.Parameters[i].Description = par.Description	×
95	}	×
96
97	return nil	5✔
98	}
99
100	func findImplementedFunction(structFunc Function, trait Trait) (*Function, bool) {	5✔
101	var sourceFunc *Function	5✔
102	for _, f := range trait.Functions {	15✔
103	if f.Name != structFunc.Name {	15✔
104	continue	5✔
105	}
106	if len(f.Overloads) == 0 {	5✔
107	if functionsMatch(structFunc, f) {	×
108	sourceFunc = f	×
109	}	×
110	break	×
111	}
112	for _, o := range f.Overloads {	10✔
113	if functionsMatch(structFunc, o) {	10✔
114	sourceFunc = o	5✔
115	break	5✔
116	}
117	}
118	break	5✔
119	}
120	return sourceFunc, sourceFunc != nil	5✔
121	}
122
123	func functionsMatch(s, t *Function) bool {	5✔
124	if len(s.Args) != len(t.Args) {	5✔
125	return false	×
126	}	×
127	if len(s.Parameters) != len(t.Parameters) {	5✔
128	return false	×
129	}	×
130
131	for i := range s.Args {	15✔
132	argS, argT := s.Args[i], t.Args[i]	10✔
133	if argS.Type != argT.Type {	15✔
134	if !(argS.Type == "Self" && argT.Type == "_Self") {	5✔
135	return false	×
136	}	×
137	}
138	if argS.PassingKind != argT.PassingKind {	10✔
139	return false	×
140	}	×
141	if argS.Convention != argT.Convention {	10✔
142	return false	×
143	}	×
144	}
145
146	for i := range s.Parameters {	5✔
147	parS, parT := s.Parameters[i], t.Parameters[i]	×
148	if parS.Type != parT.Type {	×
149	return false	×
150	}	×
151	if parS.PassingKind != parT.PassingKind {	×
152	return false	×
153	}	×
154	}
155
156	return true	5✔
157	}

mlange-42 / modo / 14250580349

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