own the usage of reflection into the RegisterType

allowing the users to only pass instances of the interfaces

admin.go

@@ -34,7 +34,6 @@ import (
 	"net/url"
 	"os"
 	"path"
-	"reflect"
 	"regexp"
 	"strconv"
 	"strings"
@@ -56,9 +55,7 @@ func init() {
 	if env, exists := os.LookupEnv("CADDY_ADMIN"); exists {
 		DefaultAdminListen = env
 	}
-	RegisterType("caddy.config_loaders", []reflect.Type{
+	RegisterType("caddy.config_loaders", []interface{}{(*ConfigLoader)(nil)})
-		reflect.TypeOf((*ConfigLoader)(nil)).Elem(),
-	})
 }
 
 // AdminConfig configures Caddy's API endpoint, which is used

caddy.go

@@ -27,7 +27,6 @@ import (
 	"os"
 	"path"
 	"path/filepath"
-	"reflect"
 	"runtime/debug"
 	"strconv"
 	"strings"
@@ -43,11 +42,11 @@ import (
 )
 
 func init() {
-	RegisterType("", []reflect.Type{
+	RegisterType("", []interface{}{
-		reflect.TypeOf((*App)(nil)).Elem(),
+		(*App)(nil),
 	})
-	RegisterType("caddy.storage", []reflect.Type{
+	RegisterType("caddy.storage", []interface{}{
-		reflect.TypeOf((*StorageConverter)(nil)).Elem(),
+		(*StorageConverter)(nil),
 	})
 }
 

caddytest/integration/types_test.go

@@ -7,8 +7,8 @@ import (
 	_ "github.com/caddyserver/caddy/v2/modules/standard"
 )
 
-// Validates Caddy's the registered internal types implement the necessary interfaces of their
+// Validates that Caddy's registered internal modules implement the necessary interfaces of their
-// namespaces
+// respective namespaces
 func TestTypes(t *testing.T) {
 	var i int
 	for _, v := range caddy.Modules() {

listeners.go

@@ -24,7 +24,6 @@ import (
 	"net"
 	"net/netip"
 	"os"
-	"reflect"
 	"strconv"
 	"strings"
 	"sync"
@@ -39,8 +38,8 @@ import (
 )
 
 func init() {
-	RegisterType("caddy.listeners", []reflect.Type{
+	RegisterType("caddy.listeners", []interface{}{
-		reflect.TypeOf((*ListenerWrapper)(nil)).Elem(),
+		(*ListenerWrapper)(nil),
 	})
 }
 

logging.go

@@ -20,7 +20,6 @@ import (
 	"io"
 	"log"
 	"os"
-	"reflect"
 	"strings"
 	"sync"
 	"time"
@@ -34,11 +33,11 @@ func init() {
 	RegisterModule(StdoutWriter{})
 	RegisterModule(StderrWriter{})
 	RegisterModule(DiscardWriter{})
-	RegisterType("caddy.logging.encoders", []reflect.Type{
+	RegisterType("caddy.logging.encoders", []interface{}{
-		reflect.TypeOf((*zapcore.Encoder)(nil)).Elem(),
+		(*zapcore.Encoder)(nil),
 	})
-	RegisterType("caddy.logging.writers", []reflect.Type{
+	RegisterType("caddy.logging.writers", []interface{}{
-		reflect.TypeOf((*WriterOpener)(nil)).Elem(),
+		(*WriterOpener)(nil),
 	})
 }
 

modules/caddyhttp/caddyauth/basicauth.go

@@ -21,7 +21,6 @@ import (
 	"fmt"
 	weakrand "math/rand"
 	"net/http"
-	"reflect"
 	"strings"
 	"sync"
 	"time"
@@ -34,11 +33,11 @@ import (
 func init() {
 	caddy.RegisterModule(HTTPBasicAuth{})
 
-	caddy.RegisterType("http.authentication.hashes", []reflect.Type{
+	caddy.RegisterType("http.authentication.hashes", []interface{}{
-		reflect.TypeOf((*Comparer)(nil)).Elem(),
+		(*Comparer)(nil),
 	})
-	caddy.RegisterType("http.authentication.providers", []reflect.Type{
+	caddy.RegisterType("http.authentication.providers", []interface{}{
-		reflect.TypeOf((*Authenticator)(nil)).Elem(),
+		(*Authenticator)(nil),
 	})
 
 	weakrand.Seed(time.Now().UnixNano())

modules/caddyhttp/encode/encode.go

@@ -26,7 +26,6 @@ import (
 	"math"
 	"net"
 	"net/http"
-	"reflect"
 	"sort"
 	"strconv"
 	"strings"
@@ -38,8 +37,8 @@ import (
 
 func init() {
 	caddy.RegisterModule(Encode{})
-	caddy.RegisterType("http.encoders", []reflect.Type{
+	caddy.RegisterType("http.encoders", []interface{}{
-		reflect.TypeOf((*Encoding)(nil)).Elem(),
+		(*Encoding)(nil),
 	})
 }
 

modules/caddyhttp/fileserver/staticfiles.go

@@ -26,7 +26,6 @@ import (
 	"os"
 	"path"
 	"path/filepath"
-	"reflect"
 	"runtime"
 	"strconv"
 	"strings"
@@ -42,8 +41,8 @@ import (
 func init() {
 	weakrand.Seed(time.Now().UnixNano())
 
-	caddy.RegisterType("http.precompressed", []reflect.Type{
+	caddy.RegisterType("http.precompressed", []interface{}{
-		reflect.TypeOf((*encode.Precompressed)(nil)).Elem(),
+		(*encode.Precompressed)(nil),
 	})
 
 	caddy.RegisterModule(FileServer{})

modules/caddyhttp/matchers.go

@@ -214,8 +214,8 @@ func init() {
 	caddy.RegisterModule(MatchHeaderRE{})
 	caddy.RegisterModule(new(MatchProtocol))
 	caddy.RegisterModule(MatchNot{})
-	caddy.RegisterType("http.matchers", []reflect.Type{
+	caddy.RegisterType("http.matchers", []interface{}{
-		reflect.TypeOf((*RequestMatcher)(nil)).Elem(),
+		(*RequestMatcher)(nil),
 	})
 }
 

modules/caddyhttp/reverseproxy/reverseproxy.go

@@ -27,7 +27,6 @@ import (
 	"net/netip"
 	"net/textproto"
 	"net/url"
-	"reflect"
 	"strconv"
 	"strings"
 	"sync"
@@ -47,17 +46,17 @@ import (
 func init() {
 	caddy.RegisterModule(Handler{})
 
-	caddy.RegisterType("http.reverse_proxy.circuit_breakers", []reflect.Type{
+	caddy.RegisterType("http.reverse_proxy.circuit_breakers", []interface{}{
-		reflect.TypeOf((*CircuitBreaker)(nil)).Elem(),
+		(*CircuitBreaker)(nil),
 	})
-	caddy.RegisterType("http.reverse_proxy.selection_policies", []reflect.Type{
+	caddy.RegisterType("http.reverse_proxy.selection_policies", []interface{}{
-		reflect.TypeOf((*Selector)(nil)).Elem(),
+		(*Selector)(nil),
 	})
-	caddy.RegisterType("http.reverse_proxy.transport", []reflect.Type{
+	caddy.RegisterType("http.reverse_proxy.transport", []interface{}{
-		reflect.TypeOf((*http.RoundTripper)(nil)).Elem(),
+		(*http.RoundTripper)(nil),
 	})
-	caddy.RegisterType("http.reverse_proxy.upstreams", []reflect.Type{
+	caddy.RegisterType("http.reverse_proxy.upstreams", []interface{}{
-		reflect.TypeOf((*UpstreamSource)(nil)).Elem(),
+		(*UpstreamSource)(nil),
 	})
 }
 

modules/caddyhttp/routes.go

@@ -18,14 +18,13 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
-	"reflect"
 
 	"github.com/caddyserver/caddy/v2"
 )
 
 func init() {
-	caddy.RegisterType("http.handlers", []reflect.Type{
+	caddy.RegisterType("http.handlers", []interface{}{
-		reflect.TypeOf((*MiddlewareHandler)(nil)).Elem(),
+		(*MiddlewareHandler)(nil),
 	})
 }
 

modules/caddytls/automation.go

@@ -20,7 +20,6 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
-	"reflect"
 	"strings"
 	"time"
 
@@ -32,14 +31,14 @@ import (
 )
 
 func init() {
-	caddy.RegisterType("dns.provider", []reflect.Type{
+	caddy.RegisterType("dns.provider", []interface{}{
-		reflect.TypeOf((*acmez.Solver)(nil)).Elem(),
+		(*acmez.Solver)(nil),
 	})
-	caddy.RegisterType("tls.get_certificate", []reflect.Type{
+	caddy.RegisterType("tls.get_certificate", []interface{}{
-		reflect.TypeOf((*certmagic.Manager)(nil)).Elem(),
+		(*certmagic.Manager)(nil),
 	})
-	caddy.RegisterType("tls.issuance", []reflect.Type{
+	caddy.RegisterType("tls.issuance", []interface{}{
-		reflect.TypeOf((*certmagic.Issuer)(nil)).Elem(),
+		(*certmagic.Issuer)(nil),
 	})
 }
 

modules/caddytls/connpolicy.go

@@ -23,7 +23,6 @@ import (
 	"io"
 	"os"
 	"path/filepath"
-	"reflect"
 	"strings"
 
 	"github.com/mholt/acmez"
@@ -34,8 +33,8 @@ import (
 
 func init() {
 	caddy.RegisterModule(LeafCertClientAuth{})
-	caddy.RegisterType("tls.handshake_match", []reflect.Type{
+	caddy.RegisterType("tls.handshake_match", []interface{}{
-		reflect.TypeOf((*ConnectionMatcher)(nil)).Elem(),
+		(*ConnectionMatcher)(nil),
 	})
 }
 

modules/caddytls/sessiontickets.go

@@ -21,7 +21,6 @@ import (
 	"fmt"
 	"io"
 	"log"
-	"reflect"
 	"runtime/debug"
 	"sync"
 	"time"
@@ -30,8 +29,8 @@ import (
 )
 
 func init() {
-	caddy.RegisterType("tls.stek", []reflect.Type{
+	caddy.RegisterType("tls.stek", []interface{}{
-		reflect.TypeOf((*STEKProvider)(nil)).Elem(),
+		(*STEKProvider)(nil),
 	})
 }
 

modules/caddytls/tls.go

@@ -21,7 +21,6 @@ import (
 	"fmt"
 	"log"
 	"net/http"
-	"reflect"
 	"runtime/debug"
 	"sync"
 	"time"
@@ -37,8 +36,8 @@ func init() {
 	caddy.RegisterModule(TLS{})
 	caddy.RegisterModule(AutomateLoader{})
 
-	caddy.RegisterType("tls.certificates", []reflect.Type{
+	caddy.RegisterType("tls.certificates", []interface{}{
-		reflect.TypeOf((*CertificateLoader)(nil)).Elem(),
+		(*CertificateLoader)(nil),
 	})
 }
 

types.go

@@ -7,7 +7,11 @@ import (
 
 var namespaceTypes map[string][]reflect.Type = make(map[string][]reflect.Type)
 
-func RegisterType(namespace string, types []reflect.Type) {
+func RegisterType(namespace string, vals []interface{}) {
+	var types []reflect.Type
+	for _, v := range vals {
+		reflect.TypeOf(v).Elem()
+	}
 	if _, ok := namespaceTypes[namespace]; ok {
 		panic("namespace is already registered")
 	}