Fixes

compiler/compile.go

@@ -372,7 +372,7 @@ func (c *compiler) compilePackage(p *packages.Package, colors functionColors) er
 		c.generateFunctypes(p, gen, colorsByFunc)
 
 		// Find all the required imports for this file.
-		gen = addImports(p, gen)
+		gen = addImports(p, f, gen)
 
 		outputPath := strings.TrimSuffix(p.GoFiles[i], ".go")
 		outputPath += "_durable.go"
@@ -400,7 +400,7 @@ func containsColoredFuncLit(decl *ast.FuncDecl, colorsByFunc map[ast.Node]*types
 	return
 }
 
-func addImports(p *packages.Package, gen *ast.File) *ast.File {
+func addImports(p *packages.Package, f *ast.File, gen *ast.File) *ast.File {
 	imports := map[string]string{}
 
 	ast.Inspect(gen, func(n ast.Node) bool {
@@ -438,6 +438,15 @@ func addImports(p *packages.Package, gen *ast.File) *ast.File {
 	}
 
 	importspecs := make([]ast.Spec, 0, len(imports))
+
+	// Preserve underscore (side effect) imports.
+	for _, imp := range f.Imports {
+		if imp.Name != nil && imp.Name.Name == "_" {
+			importspecs = append(importspecs, imp)
+		}
+	}
+
+	// Add imports for all packages used in the file.
 	for name, path := range imports {
 		importspecs = append(importspecs, &ast.ImportSpec{
 			Name: ast.NewIdent(name),
@@ -526,6 +535,8 @@ func (scope *scope) compileFuncLit(p *packages.Package, fn *ast.FuncLit, color *
 		Body: scope.compileFuncBody(p, fn.Type, fn.Body, nil, color),
 	}
 
+	p.TypesInfo.Types[gen] = types.TypeAndValue{Type: p.TypesInfo.TypeOf(fn)}
+
 	if !isExpr(gen.Body) {
 		scope.colors[gen] = color
 	}

compiler/function.go

@@ -90,7 +90,7 @@ func collectFunctypes(p *packages.Package, name string, fn ast.Node, scope *func
 		typeArg = g.typeArgOf
 	}
 
-	signature := copyFunctionType(functionTypeOf(fn))
+	signature := copyFunctionType(funcTypeWithNamedResults(p, fn))
 	signature.TypeParams = nil
 
 	recv := copyFieldList(functionRecvOf(fn))
@@ -182,6 +182,11 @@ func collectFunctypes(p *packages.Package, name string, fn ast.Node, scope *func
 			fieldName := ast.NewIdent(fmt.Sprintf("X%d", i))
 			fieldType := freeVar.typ
 
+			// Convert ellipsis into slice (...X => []X).
+			if e, ok := fieldType.(*ast.Ellipsis); ok {
+				fieldType = &ast.ArrayType{Elt: e.Elt}
+			}
+
 			// The Go compiler uses a more advanced mechanism to determine if a
 			// free variable should be captured by pointer or by value: it looks
 			// at whether the variable is reassigned, its address taken, and if

compiler/types.go

@@ -52,9 +52,6 @@ func typeExpr(p *packages.Package, typ types.Type, typeArg func(*types.TypeParam
 		if t.Empty() {
 			return ast.NewIdent("any")
 		}
-		if t.NumEmbeddeds() > 0 {
-			panic("not implemented: interface with embeddeds")
-		}
 		methods := make([]*ast.Field, t.NumExplicitMethods())
 		for i := range methods {
 			m := t.ExplicitMethod(i)
@@ -63,8 +60,16 @@ func typeExpr(p *packages.Package, typ types.Type, typeArg func(*types.TypeParam
 				Type:  typeExpr(p, m.Type(), typeArg),
 			}
 		}
+		embeddeds := make([]*ast.Field, t.NumEmbeddeds())
+		for i := range embeddeds {
+			embeddeds[i] = &ast.Field{
+				Type: typeExpr(p, t.EmbeddedType(i), typeArg),
+			}
+		}
 		return &ast.InterfaceType{
-			Methods: &ast.FieldList{List: methods},
+			Methods: &ast.FieldList{
+				List: append(methods, embeddeds...),
+			},
 		}
 	case *types.Signature:
 		return newFuncType(p, t, typeArg)
@@ -197,6 +202,15 @@ func substituteTypeArgs(p *packages.Package, expr ast.Expr, typeArg func(*types.
 			X:     substituteTypeArgs(p, e.X, typeArg),
 			Index: substituteTypeArgs(p, e.Index, typeArg),
 		}
+	case *ast.IndexListExpr:
+		indices := make([]ast.Expr, len(e.Indices))
+		for i, index := range e.Indices {
+			indices[i] = substituteTypeArgs(p, index, typeArg)
+		}
+		return &ast.IndexListExpr{
+			X:       substituteTypeArgs(p, e.X, typeArg),
+			Indices: indices,
+		}
 	case *ast.Ident:
 		t := p.TypesInfo.TypeOf(e)
 		tp, ok := t.(*types.TypeParam)