Golang struct assignability and type identity

I have the following 2 structs:

    func main() {
    	type A struct {
    		v int
    	}
    	type B struct {
    		v int
    	}
    	var b B = A{}
    }

The assignment var b B = A{} fails with an error message:
> Cannot use 'A{}' (type A) as the type B

But in the golang spec:Type identity it says:
> Two struct types are identical if they have the same sequence of fields, and if corresponding fields have the same names, and identical types, and identical tags. Non-exported field names from different packages are always different.

so, I expect types A and B to be identical. And in the spec:Assignability it says:
> A value x is assignable to a variable of type T ("x is assignable to T") if one of the following conditions applies:
> - x's type is identical to T.

given all that information, I tend to think that the assignment should be succeeded since the type of A{} is identical to B, but apparently I'm missing something.

So, what am I missing here to understand the root cause of the error message?

Note that the definition you pointed to starts with:

A defined type is always different from any other type.

A and B are defined types, they have different names, so they are different. The type struct { v int } is identical to any type struct {v int}, but in this case, these are not defined types. For instance, you can declare:

func f(x struct {v int})

Then you can call:

f(struct {v int}{v:1})

The two structs are equal.

You can still assign A and B using:

var b B = B(A{})

This works because the underlying types of A and B are structurally identical.

So given types A and B defined as:

    type A struct {
        v int
    }

    type B struct {
        v int
    }

Are the types identical?

No. From Type Definitions:

> A type definition creates a new, distinct type with the same underlying type

What are A and B underlying types?

Both are struct { v int }. From

> If T is one of the predeclared boolean, numeric, or string types, or a type literal, the corresponding underlying type is T itself.

So given that a type declaration is in the form TypeSpec = AliasDecl | TypeDef . and TypeDef = identifier Type . you can pattern-match your types and see that both A and B conform to the type definition where:

• A and B are the identifiers and
• struct { v int } is their underlying struct type literal.

How does assignment work?

From Assignability you can see that no condition applies:

• x's type is identical to T. — A and B are not identical because both are different defined types
• x's type V and T have identical underlying types and at least one of V or T is not a defined type. — both are defined types

So a variable of type A is not assignable to a variable of type B and vice-versa. Non-assignability also means that you can't pass a variable of type A to a function parameter of type B, because:

> arguments must be single-valued expressions assignable to the parameter types of F

The example in Burak's answer with func foo(x struct{ v int }) compiles because foo's param type is a struct literal, not a defined type, and falls under the conditions for assignability.

How does conversion work?

You can convert from A to B because, from Conversion`:

> A non-constant value x can be converted to type T in any of these cases:
>
> - [...]
> - ignoring struct tags (see below), x's type and T have identical underlying types.

And we proved above that both structs do indeed have identical underlying types. Therefore this compiles:

var a A = A(B{})

<hr>

Playground: https://play.golang.org/p/UyEYrbUufA5