func (p *parser) parseReturnStmt(n *parse.Node) ast.Stmt {
	ret := ast.ReturnStmt{
		Return: token.Pos(n.Child(0).Pos()),
	}
	if n.ChildCount() > 1 {
		ret.Results = p.parseExprList(n.Child(1))
	}
	return &ret
}

func (a *stmtCompiler) compileReturnStmt(s *ast.ReturnStmt) {
	if a.fnType == nil {
		a.diag("cannot return at the top level")
		return
	}

	if len(s.Results) == 0 && (len(a.fnType.Out) == 0 || a.outVarsNamed) {
		// Simple case.  Simply exit from the function.
		a.flow.putTerm()
		a.push(func(v *Thread) { v.pc = returnPC })
		return
	}

	bc := a.enterChild()
	defer bc.exit()

	// Compile expressions
	bad := false
	rs := make([]*expr, len(s.Results))
	for i, re := range s.Results {
		rs[i] = a.compileExpr(bc.block, false, re)
		if rs[i] == nil {
			bad = true
		}
	}
	if bad {
		return
	}

	// Create assigner

	// However, if the expression list in the "return" statement
	// is a single call to a multi-valued function, the values
	// returned from the called function will be returned from
	// this one.
	assign := a.compileAssign(s.Pos(), bc.block, NewMultiType(a.fnType.Out), rs, "return", "value")

	// XXX(Spec) "The result types of the current function and the
	// called function must match."  Match is fuzzy.  It should
	// say that they must be assignment compatible.

	// Compile
	start := len(a.fnType.In)
	nout := len(a.fnType.Out)
	a.flow.putTerm()
	a.push(func(t *Thread) {
		assign(multiV(t.f.Vars[start:start+nout]), t)
		t.pc = returnPC
	})
}

func (f *File) validRetStmt(ret *ast.ReturnStmt) *Error {
	// returning nothing is ok
	if ret.Results == nil || len(ret.Results) == 0 {
		return nil
	}
	// Cannot return multiple values
	if len(ret.Results) > 1 {
		return &Error{errors.New("Return statements can only have one result"), ret.Pos()}
	}
	expr := ret.Results[0]
	if err := f.validRetExpr(expr); err != nil {
		return err
	}
	return nil
}