compiler: process literals in analyzeVoidCalls

Function call can occur in the slice or map literal
and its result surely isn't unused.

pkg/compiler/func_scope.go

@@ -136,6 +136,18 @@ func (c *funcScope) analyzeVoidCalls(node ast.Node) bool {
 			c.voidCalls[n] = true
 		}
 		return false
+	case *ast.CompositeLit:
+		for _, e := range n.Elts {
+			switch val := e.(type) {
+			case *ast.CallExpr: // slice
+				c.voidCalls[val] = false
+			case *ast.KeyValueExpr: // struct and map
+				ce, ok := val.Value.(*ast.CallExpr)
+				if ok {
+					c.voidCalls[ce] = false
+				}
+			}
+		}
 	}
 	return true
 }

pkg/compiler/slice_test.go

@@ -321,6 +321,15 @@ var sliceTestCases = []testCase{
 		}`,
 		[]byte("string"),
 	},
+	{
+		"literal slice with function call",
+		`package foo
+		func fn() byte { return 't' }
+		func Main() []byte {
+			return []byte{'s', fn(), 'r'}
+		}`,
+		[]byte("str"),
+	},
 }
 
 func TestSliceOperations(t *testing.T) {

pkg/compiler/struct_test.go

@@ -29,6 +29,19 @@ var structTestCases = []testCase{
 		`,
 		big.NewInt(2),
 	},
+	{
+		"struct field from func result",
+		`
+		package foo
+		type S struct { x int }
+		func fn() int { return 2 }
+		func Main() int {
+			t := S{x: fn()}
+			return t.x
+		}
+		`,
+		big.NewInt(2),
+	},
 	{
 		"struct field return",
 		`