Yes, this is a dup of #31777. I'll close this one, but the test case should be very useful.

Sounds like the proposed fix to #31777 may not handle this. Reopening until we have confirmed that this is fixed and has a test.

@randall77 @josharian the problem seems to be this line in OMAPLIT order:

as := nod(OAS, nod(OINDEX, n, r.Left), r.Right)

The old code requires a temp, so that mapassign1 can have addressable key, elem:

// Build list of var[c] = expr.
	// Use temporaries so that mapassign1 can have addressable key, elem.
	// TODO(josharian): avoid map key temporaries for mapfast_* assignments with literal keys.
	tmpkey := temp(m.Type.Key())
	tmpelem := temp(m.Type.Elem())

	for _, r := range entries {
		index, elem := r.Left, r.Right

		setlineno(index)
		a := nod(OAS, tmpkey, index)
		a = typecheck(a, ctxStmt)
		a = walkstmt(a)
		init.Append(a)

		setlineno(elem)
		a = nod(OAS, tmpelem, elem)
		a = typecheck(a, ctxStmt)
		a = walkstmt(a)
		init.Append(a)

		setlineno(tmpelem)
		a = nod(OAS, nod(OINDEX, m, tmpkey), tmpelem)
		a = typecheck(a, ctxStmt)
		a = walkstmt(a)
		init.Append(a)
	}

How can we archive the same behavior for order?

Hmmm, order.go should allocate those temporaries, the OINDEXMAP case in expr.
It should occur when we call o.stmt on the results of nod(OAS, nod(OINDEX, n, r.Left), r.Right).

Change https://golang.org/cl/174837 mentions this issue: cmd/compile: fix order fails to initialize map dynamic entry

Not yet fully minimized, but here's some progress:

package main

import (
	"fmt"

	"github.com/influxdata/flux/semantic"
)

func main() {
        fmt.Println(semantic.NewFunctionPolyType(semantic.FunctionPolySignature{
                Return: semantic.Time,
        }))
}

This used to print () -> time, but at master it currently prints () -> <nil>.

Standalone test file:

package main

import "fmt"

type Nature int

const Time Nature = 0

var natureNames = []string{
	"time",
}

func (n Nature) String() string {
	return natureNames[n]
}

type function struct {
	ret interface{}
}

type FunctionPolySignature struct {
	Required []string
	Return   interface{}
}

func NewFunctionPolyType2(sig FunctionPolySignature) interface{} {
	return function{
		ret: sig.Return,
	}
}

func (f function) String() string {
	return fmt.Sprint(f.ret)
}

func main() {
	fmt.Println(NewFunctionPolyType2(FunctionPolySignature{
		Return: Time,
	}))
}

Used to print time; now prints <nil>.

More minimal:

package main

type one struct {
	i interface{}
}

type two struct {
	i interface{}
	s []string
}

func main() {
	o := one{i: two{i: 42}.i}
	println(o.i.(int))
}

Should print 42, but currently panics.

That's about as far as I think I have time to dig into this at the moment.

@randall77 or @cuonglm , do you mind investigating further?

@mdempsky /me will take a look shortly.

Sounds like it dues changes in isStaticCompositeLiteral.

Just slightly more reduced:

package main

type foo struct {
	i interface{}
	_, _ interface{}
}

func main() {
	z := foo{i: 42}.i
	println(z.(int))
}

Playing with the other fields in foo seems to trigger the bug. A single anonymous interface field doesn't cause it, but two fields do. _ [1]int doesn't cause it, but _ [2]int does. It happens whether the other fields are before or after i.

@mdempsky @mark-rushakoff I'm running dist test before submit the patch.

I think my assumption is right.

The ONAME case in isStaticCompositeLiteral reports the second i: in o := one{i: two{i: 42}.i} as compile-time constant, why it shouldn't.

@mark-rushakoff with newest patch in CL, I can run the test and both examples run without panic.

Confirmed that the behavior is fixed on tip. Thank you!