coroc: better handle chained function calls (#100)

This fixes some odd expression decomposition I noticed. In the worst
case (all functions in the chain may yield), a chain like
`time.Now().UTC()` is decomposed to:

```go
{
    _v2 := time.Now
    _v1 := _v2()
    _v0 := _v1.UTC
    _v0()
}
```

Although this is technically correct, it can cause issues with
serialization because the function types aren't necessarily registered.

This PR improves the handling of `ast.CallExpr` + `ast.SelectorExpr` so
that we instead get the following (in the worst case):

```go
{
    _v0 := time.Now()
    _v0.UTC()
}
```

compiler/desugar.go

@@ -767,11 +767,15 @@ const (
 )
 
 func (d *desugarer) mayYield(n ast.Node) bool {
-	switch n.(type) {
+	switch x := n.(type) {
 	case nil:
 		return false
 	case *ast.BasicLit, *ast.FuncLit, *ast.Ident:
 		return false
+	case *ast.SelectorExpr:
+		if _, ok := x.X.(*ast.Ident); ok {
+			return false
+		}
 	case *ast.ArrayType, *ast.ChanType, *ast.FuncType, *ast.InterfaceType, *ast.MapType, *ast.StructType:
 		return false
 	}
@@ -820,7 +824,11 @@ func (d *desugarer) decomposeExpression(expr ast.Expr, flags exprFlags) (ast.Exp
 					continue
 				}
 			}
-			e.Fun = decompose(e.Fun)
+			if se, ok := e.Fun.(*ast.SelectorExpr); ok && d.mayYield(se.X) {
+				se.X = decompose(se.X)
+			} else {
+				e.Fun = decompose(e.Fun)
+			}
 			for i, arg := range e.Args {
 				e.Args[i] = decompose(arg)
 			}

compiler/desugar_test.go

@@ -1134,6 +1134,16 @@ defer func() {
 		foo(_v0, _v1)
 	}()
 }
+`,
+		},
+		{
+			name: "repeated function calls",
+			body: "time.Now().UTC()",
+			expect: `
+{
+	_v0 := time.Now()
+	_v0.UTC()
+}
 `,
 		},
 	} {