package main

import (
        "fmt"
        "go/ast"
        "go/importer"
        "go/parser"
        "go/token"
        "go/types"
        "log"
)

// passes if analyzed this direction.
var srcs = []string{`
package a
import "io"
type Metric interface {
        Write(*io.Writer) error
}`, `
package a
type Untyped interface {
        Metric
}
`, `
package a
type value struct {
        selfCollector
}`, `
package a
type Collector interface {
}
type selfCollector struct {
        self Metric
}
func (c *selfCollector) init(self Metric) {
        c.self = self
}`}

func typecheck() {
        fset := token.NewFileSet()
        conf := types.Config{
                Importer: importer.For("source", nil),
                Error:    func(err error) { log.Println(err) },
        }
        files := []*ast.File{}
        for i, src := range srcs {
                parsed, err := parser.ParseFile(fset, fmt.Sprintf("f%d.go", i), src, 0)
                if err != nil {
                        log.Fatal(err)
                }
                files = append(files, parsed)
        }
        _, err := conf.Check(".", fset, files, nil)
        if err != nil {
                fmt.Println("bad typecheck!")
        }
}

func main() {
        typecheck()
        fmt.Println("first check succeeded")
        srcs[0], srcs[1], srcs[2] = srcs[1], srcs[2], srcs[0]
        typecheck()
}

package bug
import "go/ast"
type A interface { B }

package bug
import "go/ast"
type B interface { b() ast.Node }