Make it more robust

Signed-off-by: Pavol Loffay <[email protected]>

Author: pavolloffay

cmd/builder/go.mod

@@ -26,7 +26,7 @@ require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
-	github.com/hashicorp/go-version v1.7.0 // indirect
+	github.com/hashicorp/go-version v1.8.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/knadh/koanf/maps v0.1.2 // indirect

cmd/builder/go.sum

@@ -5,6 +5,8 @@ package schemagen // import "go.opentelemetry.io/collector/cmd/builder/internal/
 
 import (
 	"fmt"
+	"go/ast"
+	"go/token"
 	"go/types"
 
 	"golang.org/x/tools/go/packages"
@@ -55,33 +57,163 @@ func (pa *PackageAnalyzer) LoadPackage(importPath string) (*packages.Package, er
 }
 
 // FindConfigType locates the Config struct in a component package.
-// It looks for a type named "Config" that is a struct.
+// It first searches for compile-time check patterns like:
+//
+//	var _ component.Config = (*ConfigType)(nil)
+//
+// If no such pattern is found, it falls back to looking for a type named "Config".
 func (pa *PackageAnalyzer) FindConfigType(pkg *packages.Package) (*types.Named, error) {
 	if pkg.Types == nil {
 		return nil, fmt.Errorf("package %s has no type information", pkg.PkgPath)
 	}
 
+	// Search AST for compile-time check pattern
+	configTypeName := pa.findConfigTypeFromAST(pkg)
+	if configTypeName != "" {
+		return pa.findConfigTypeByName(pkg, configTypeName)
+	}
+
+	// Fallback to looking for "Config" type by name
+	return pa.findConfigTypeByName(pkg, "Config")
+}
+
+// findConfigTypeByName looks up a type by name in the package scope.
+func (pa *PackageAnalyzer) findConfigTypeByName(pkg *packages.Package, typeName string) (*types.Named, error) {
 	scope := pkg.Types.Scope()
 
-	// Look for "Config" type
-	obj := scope.Lookup("Config")
+	obj := scope.Lookup(typeName)
 	if obj == nil {
-		return nil, fmt.Errorf("no Config type found in package %s", pkg.PkgPath)
+		return nil, fmt.Errorf("no %s type found in package %s", typeName, pkg.PkgPath)
 	}
 
 	named, ok := obj.Type().(*types.Named)
 	if !ok {
-		return nil, fmt.Errorf("config in package %s is not a named type", pkg.PkgPath)
+		return nil, fmt.Errorf("%s in package %s is not a named type", typeName, pkg.PkgPath)
 	}
 
 	// Verify it's a struct
 	if _, ok := named.Underlying().(*types.Struct); !ok {
-		return nil, fmt.Errorf("config in package %s is not a struct", pkg.PkgPath)
+		return nil, fmt.Errorf("%s in package %s is not a struct", typeName, pkg.PkgPath)
 	}
 
 	return named, nil
 }
 
+// findConfigTypeFromAST searches for compile-time check patterns in the package AST.
+// It looks for patterns like: var _ component.Config = (*ConfigType)(nil)
+func (pa *PackageAnalyzer) findConfigTypeFromAST(pkg *packages.Package) string {
+	for _, file := range pkg.Syntax {
+		if typeName := pa.findConfigTypeInFile(file); typeName != "" {
+			return typeName
+		}
+	}
+	return ""
+}
+
+// findConfigTypeInFile searches a single file for the compile-time check pattern.
+func (pa *PackageAnalyzer) findConfigTypeInFile(file *ast.File) string {
+	for _, decl := range file.Decls {
+		genDecl, ok := decl.(*ast.GenDecl)
+		if !ok || genDecl.Tok != token.VAR {
+			continue
+		}
+
+		for _, spec := range genDecl.Specs {
+			valueSpec, ok := spec.(*ast.ValueSpec)
+			if !ok {
+				continue
+			}
+
+			if typeName := pa.extractConfigTypeFromValueSpec(valueSpec); typeName != "" {
+				return typeName
+			}
+		}
+	}
+	return ""
+}
+
+// extractConfigTypeFromValueSpec checks if a ValueSpec matches the pattern:
+// var _ component.Config = (*ConfigType)(nil)
+func (pa *PackageAnalyzer) extractConfigTypeFromValueSpec(spec *ast.ValueSpec) string {
+	// Must have exactly one name and it must be blank identifier
+	if len(spec.Names) != 1 || spec.Names[0].Name != "_" {
+		return ""
+	}
+
+	// Check if the type is component.Config
+	if !pa.isComponentConfigType(spec.Type) {
+		return ""
+	}
+
+	// Must have exactly one value
+	if len(spec.Values) != 1 {
+		return ""
+	}
+
+	// Extract type name from (*TypeName)(nil)
+	return pa.extractTypeFromConversionExpr(spec.Values[0])
+}
+
+// isComponentConfigType checks if the type expression represents component.Config.
+func (pa *PackageAnalyzer) isComponentConfigType(typeExpr ast.Expr) bool {
+	sel, ok := typeExpr.(*ast.SelectorExpr)
+	if !ok {
+		return false
+	}
+
+	// Check for "Config" selector
+	if sel.Sel.Name != "Config" {
+		return false
+	}
+
+	// Check for "component" package identifier
+	ident, ok := sel.X.(*ast.Ident)
+	if !ok {
+		return false
+	}
+
+	return ident.Name == "component"
+}
+
+// extractTypeFromConversionExpr extracts the type name from a (*TypeName)(nil) expression.
+func (pa *PackageAnalyzer) extractTypeFromConversionExpr(expr ast.Expr) string {
+	// The expression should be a call expression: (*TypeName)(nil)
+	callExpr, ok := expr.(*ast.CallExpr)
+	if !ok {
+		return ""
+	}
+
+	// Should have exactly one argument (nil)
+	if len(callExpr.Args) != 1 {
+		return ""
+	}
+
+	// Verify the argument is nil
+	ident, ok := callExpr.Args[0].(*ast.Ident)
+	if !ok || ident.Name != "nil" {
+		return ""
+	}
+
+	// Fun should be a parenthesized star expression: (*TypeName)
+	parenExpr, ok := callExpr.Fun.(*ast.ParenExpr)
+	if !ok {
+		return ""
+	}
+
+	starExpr, ok := parenExpr.X.(*ast.StarExpr)
+	if !ok {
+		return ""
+	}
+
+	// Extract the type name
+	typeIdent, ok := starExpr.X.(*ast.Ident)
+	if !ok {
+		return ""
+	}
+
+	return typeIdent.Name
+}
+
 // GetStructFromNamed extracts the underlying struct type from a named type.
 func GetStructFromNamed(named *types.Named) (*types.Struct, bool) {
 	st, ok := named.Underlying().(*types.Struct)

cmd/builder/internal/schemagen/analyzer.go

@@ -372,6 +372,20 @@ func TestPackageAnalyzer_NewPackageAnalyzer(t *testing.T) {
 	assert.Equal(t, tempDir, analyzer.cfg.Dir)
 }
 
+func TestPackageAnalyzer_FindConfigType_WithCompileTimeCheck(t *testing.T) {
+	cwd, err := os.Getwd()
+	require.NoError(t, err)
+
+	// testcomponent uses "MySettings" (not "Config") to verify AST-based detection
+	analyzer := NewPackageAnalyzer(filepath.Join(cwd, "..", ".."))
+	pkg, err := analyzer.LoadPackage("go.opentelemetry.io/collector/cmd/builder/internal/schemagen/testdata/testcomponent")
+	require.NoError(t, err)
+
+	configType, err := analyzer.FindConfigType(pkg)
+	require.NoError(t, err)
+	assert.Equal(t, "MySettings", configType.Obj().Name())
+}
+
 func TestBasicTypeToSchema(t *testing.T) {
 	tests := []struct {
 		name     string

cmd/builder/internal/schemagen/generator_test.go

@@ -4,14 +4,21 @@
 // Package testcomponent provides a test configuration for schema generation testing.
 // It covers all basic Go types, special types (time.Duration), nested structs,
 // slices, maps, and deprecation detection.
+// The config type is intentionally named "MySettings" (not "Config") to test
+// that schema generation detects config types via compile-time checks.
 package testcomponent // import "go.opentelemetry.io/collector/cmd/builder/internal/schemagen/testdata/testcomponent"
 
 import (
 	"time"
+
+	"go.opentelemetry.io/collector/component"
 )
 
-// Config is the configuration for the test component.
-type Config struct {
+// Compile-time check that MySettings implements component.Config.
+var _ component.Config = (*MySettings)(nil)
+
+// MySettings is the configuration for the test component.
+type MySettings struct {
 	// Name is the name of the component.
 	Name string `mapstructure:"name"`