Method parseInterface

parser/parser.go:605–651

()

}

func (p *parser) parseInterface() error {
	s := p.s
	t, err := expectTagContents(s)
	if err != nil {
		return err
	}

	n := bytes.IndexByte(t.Value, '{')
	if n < 0 {
		return fmt.Errorf("missing '{' in interface at %s", s.Context())
	}
	ifname := string(stripTrailingSpace(t.Value[:n]))
	if len(ifname) == 0 {
		return fmt.Errorf("missing interface name at %s", s.Context())
	}
	p.Printf("type %s interface {", ifname)
	p.prefix = "\t"

	tail := t.Value[n:]
	exprStr := fmt.Sprintf("interface %s", tail)
	expr, err := goparser.ParseExpr(exprStr)
	if err != nil {
		return fmt.Errorf("error when parsing interface at %s: %s", s.Context(), err)
	}
	it, ok := expr.(*ast.InterfaceType)
	if !ok {
		return fmt.Errorf("unexpected interface type at %s: %T", s.Context(), expr)
	}
	methods := it.Methods.List
	if len(methods) == 0 {
		return fmt.Errorf("interface must contain at least one method at %s", s.Context())
	}

	for _, m := range it.Methods.List {
		methodStr := exprStr[m.Pos()-1 : m.End()-1]
		f, err := parseFuncDef([]byte(methodStr))
		if err != nil {
			return fmt.Errorf("when when parsing %q at %s: %s", methodStr, s.Context(), err)
		}
		p.Printf("%s string", methodStr)
		p.Printf("%s", f.DefStream("qw"+mangleSuffix))
		p.Printf("%s", f.DefWrite("qq"+mangleSuffix))
	}
	p.prefix = ""
	p.Printf("}")
	return nil
}

func (p *parser) parsePackageName() error {
	t, err := expectTagContents(p.s)