refactor: improve error handling and code structure

Author: xfrr

.golangci.yaml

@@ -72,7 +72,6 @@ linters:
   - goconst # finds repeated strings that could be replaced by a constant
   - gocritic # provides diagnostics that check for bugs, performance and style issues
   - gocyclo # computes and checks the cyclomatic complexity of functions
-  - godot # checks if comments end in a period
   - gomoddirectives # manages the use of 'replace', 'retract', and 'excludes' directives in go.mod
   - goprintffuncname # checks that printf-like functions are named with f at the end
   - gosec # inspects source code for security problems
@@ -433,8 +432,6 @@ linters:
     - common-false-positives
     # Excluding configuration per-path, per-linter, per-text and per-source.
     rules:
-    - source: 'TODO'
-      linters: [ godot ]
     - text: 'should have a package comment'
       linters: [ revive ]
     - text: 'exported \S+ \S+ should have comment( \(or a comment on this block\))? or be unexported'
@@ -445,8 +442,35 @@ linters:
     - text: 'comment on exported \S+ \S+ should be of the form ".+"'
       source: '// ?(nolint|TODO)'
       linters: [ revive, staticcheck ]
+
+    - path: 'cmd/assemble/.*\.go'
+      linters:
+      - forbidigo
+      - gochecknoglobals
+      - gosec
+
+    - path: 'example/.*\.go'
+      linters:
+      - forbidigo
+      - gochecknoglobals
+      - gosec
+
+    - path: 'test/.*\.go'
+      linters:
+      - forbidigo
+      - gochecknoglobals
+      - bodyclose
+      - dupl
+      - errcheck
+      - funlen
+      - goconst
+      - gosec
+      - noctx
+      - wrapcheck
+
     - path: '_test\.go'
       linters:
+      - forbidigo
       - bodyclose
       - dupl
       - errcheck

cmd/assemble/main.go

@@ -16,12 +16,12 @@ import (
 
 func main() {
 	var (
-		pkgArg  = flag.String("pkg", ".", "Go package (import path or ./relative)")
-		varName = flag.String("var", "Core", "assemble.Module variable name to parse")
-		out     = flag.String("o", "gen.go", "output file (e.g., ./build_assemble_gen.go)")
+		pkgArg     = flag.String("pkg", ".", "Go package (import path or ./relative)")
+		varName    = flag.String("var", "Core", "assemble.Module variable name to parse")
+		outputPath = flag.String("o", "gen.go", "output file (e.g., ./build_assemble_gen.go)")
 	)
 	flag.Parse()
-	if *out == "" {
+	if *outputPath == "" {
 		log.Fatal("-o output file is required")
 	}
 
@@ -33,33 +33,33 @@ func main() {
 		Tests: false,
 	}
 
-	pkgs, err := packages.Load(cfg, *pkgArg)
-	if err != nil {
-		log.Fatalf("load: %v", err)
+	pkgs, loadErr := packages.Load(cfg, *pkgArg)
+	if loadErr != nil {
+		log.Fatalf("load: %v", loadErr)
 	}
 	if packages.PrintErrors(pkgs) > 0 || len(pkgs) == 0 {
 		log.Fatalf("failed loading package %q", *pkgArg)
 	}
 	p := pkgs[0]
 
-	mod, err := parser.ExtractModule(p, *varName, fset)
-	if err != nil {
-		log.Fatalf("parse module: %v", err)
+	mod, extractErr := parser.ExtractModule(p, *varName, fset)
+	if extractErr != nil {
+		log.Fatalf("parse module: %v", extractErr)
 	}
 
-	src, err := render.Emit(*varName, p.Name, *out, mod)
-	if err != nil {
-		log.Fatalf("render: %v", err)
+	src, emitErr := render.Emit(*varName, p.Name, *outputPath, mod)
+	if emitErr != nil {
+		log.Fatalf("render: %v", emitErr)
 	}
 
-	if err := os.MkdirAll(filepath.Dir(*out), 0o755); err != nil {
-		log.Fatalf("mkdir: %v", err)
+	if mkdirErr := os.MkdirAll(filepath.Dir(*outputPath), 0o755); mkdirErr != nil {
+		log.Fatalf("mkdir: %v", mkdirErr)
 	}
-	if err := os.WriteFile(*out, []byte(src), 0o644); err != nil {
-		log.Fatalf("write: %v", err)
+	if writeErr := os.WriteFile(*outputPath, []byte(src), 0o644); writeErr != nil {
+		log.Fatalf("write: %v", writeErr)
 	}
 
-	fmt.Printf("assemblegen: wrote %s (%d bytes)\n", *out, len(src))
+	fmt.Printf("assemblegen: wrote %s (%d bytes)\n", *outputPath, len(src))
 }
 
 func dirFor(arg string) string {

container.go

@@ -250,7 +250,11 @@ func (c *Container) resolveViaBind(ctx context.Context, k Key) (any, error) {
 				return nil, err
 			}
 			if !reflect.TypeOf(v).Implements(k.typ) {
-				return nil, BindError{From: k.typ, To: pk.typ, Why: "implementation does not satisfy interface at runtime"}
+				return nil, BindError{
+					From: k.typ,
+					To:   pk.typ,
+					Why:  "implementation does not satisfy interface at runtime",
+				}
 			}
 			return v, nil
 		}

example/core_assemble_gen.go

@@ -40,6 +40,10 @@ const (
 	kindStop  = "stop"
 )
 
+const (
+	provideFuncParamCount = 2 // (context.Context, assemble.Resolver)
+)
+
 // ExtractModule scans the given package for a variable named `varName`
 // and attempts to parse its value as an assemble module definition.
 func ExtractModule(p *packages.Package, varName string, fset *token.FileSet) (Model, error) {
@@ -458,9 +462,10 @@ func fillProvideFromExpr(p *packages.Package, pr *Provide, expr ast.Expr) {
 }
 
 func fillProvideFromSignature(p *packages.Package, pr *Provide, sig *types.Signature) {
-	if sig.Params().Len() == 1 && isResolverLike(sig.Params().At(0).Type()) {
+	if sig.Params().Len() == provideFuncParamCount && isResolverLike(sig.Params().At(1).Type()) {
 		pr.TakesResolve = true
 	}
+
 	switch sig.Results().Len() {
 	case 1:
 		pr.ResType = typeString(p, sig.Results().At(0).Type())