NewDefaultConf: add (noTestFile bool) param

cmd/internal/build/build.go

@@ -74,7 +74,7 @@ func runCmd(cmd *base.Command, args []string) {
 		log.Panicln("too many arguments:", args)
 	}
 
-	conf, err := gop.NewDefaultConf(".")
+	conf, err := gop.NewDefaultConf(".", true)
 	if err != nil {
 		log.Panicln("gop.NewDefaultConf:", err)
 	}

cmd/internal/gengo/go.go

@@ -71,7 +71,7 @@ func runCmd(cmd *base.Command, args []string) {
 		cl.SetDisableRecover(true)
 	}
 
-	conf, err := gop.NewDefaultConf(".")
+	conf, err := gop.NewDefaultConf(".", false)
 	if err != nil {
 		log.Panicln("gop.NewDefaultConf:", err)
 	}

cmd/internal/install/install.go

@@ -71,7 +71,7 @@ func runCmd(cmd *base.Command, args []string) {
 		cl.SetDisableRecover(true)
 	}
 
-	conf, err := gop.NewDefaultConf(".")
+	conf, err := gop.NewDefaultConf(".", true)
 	if err != nil {
 		log.Panicln("gop.NewDefaultConf:", err)
 	}

cmd/internal/run/run.go

@@ -80,7 +80,7 @@ func runCmd(cmd *base.Command, args []string) {
 	}
 
 	noChdir := *flagNoChdir
-	conf, err := gop.NewDefaultConf(".")
+	conf, err := gop.NewDefaultConf(".", true)
 	if err != nil {
 		log.Panicln("gop.NewDefaultConf:", err)
 	}

cmd/internal/test/test.go

@@ -69,7 +69,7 @@ func runCmd(cmd *base.Command, args []string) {
 		cl.SetDisableRecover(true)
 	}
 
-	conf, err := gop.NewDefaultConf(".")
+	conf, err := gop.NewDefaultConf(".", false)
 	if err != nil {
 		log.Panicln("gop.NewDefaultConf:", err)
 	}

load.go

@@ -21,6 +21,7 @@ import (
 	"go/types"
 	"io/fs"
 	"os"
+	"path"
 	"strings"
 
 	"github.com/goplus/gop/ast"
@@ -126,20 +127,26 @@ type Config struct {
 	DontUpdateGoMod    bool
 }
 
-func NewDefaultConf(dir string) (conf *Config, err error) {
+// NewDefaultConf creates a dfault configuration for common cases.
+func NewDefaultConf(dir string, noTestFile bool) (conf *Config, err error) {
 	mod, err := LoadMod(dir)
 	if err != nil {
 		return
 	}
 	gop := gopenv.Get()
 	fset := token.NewFileSet()
 	imp := NewImporter(mod, gop, fset)
-	return &Config{Gop: gop, Fset: fset, Mod: mod, Importer: imp}, nil
+	conf = &Config{Gop: gop, Fset: fset, Mod: mod, Importer: imp}
+	if noTestFile {
+		conf.Filter = FilterNoTestFiles
+	}
+	return
 }
 
+// LoadMod loads a Go+ module from a specified directory.
 func LoadMod(dir string) (mod *gopmod.Module, err error) {
 	mod, err = gopmod.Load(dir)
-	if err != nil && !NotFound(err) {
+	if err != nil && !gopmod.IsNotFound(err) {
 		err = errors.NewWith(err, `gopmod.Load(dir, 0)`, -2, "gopmod.Load", dir, 0)
 		return
 	}
@@ -153,13 +160,31 @@ func LoadMod(dir string) (mod *gopmod.Module, err error) {
 	return gopmod.Default, nil
 }
 
+// FilterNoTestFiles filters to skip all testing files.
+func FilterNoTestFiles(fi fs.FileInfo) bool {
+	fname := fi.Name()
+	suffix := ""
+	switch path.Ext(fname) {
+	case ".gox":
+		suffix = "test.gox"
+	case ".gop":
+		suffix = "_test.gop"
+	case ".go":
+		suffix = "_test.go"
+	default:
+		return true
+	}
+	return !strings.HasSuffix(fname, suffix)
+}
+
 func hasModfile(mod *gopmod.Module) bool {
 	f := mod.File
 	return f != nil && f.Syntax != nil
 }
 
 // -----------------------------------------------------------------------------
 
+// LoadDir loads Go+ packages from a specified directory.
 func LoadDir(dir string, conf *Config, genTestPkg bool, promptGenGo ...bool) (out, test *gox.Package, err error) {
 	if conf == nil {
 		conf = new(Config)
@@ -271,6 +296,7 @@ func relativeBaseOf(mod *gopmod.Module) string {
 
 // -----------------------------------------------------------------------------
 
+// LoadDir loads a Go+ package from specified files.
 func LoadFiles(dir string, files []string, conf *Config) (out *gox.Package, err error) {
 	if conf == nil {
 		conf = new(Config)

parser/parser_gop.go

@@ -229,7 +229,7 @@ func ParseFSEntry(fset *token.FileSet, fs FileSystem, filename string, src inter
 
 func filter(d fs.DirEntry, fn func(fs.FileInfo) bool) bool {
 	fi, err := d.Info()
-	return err != nil || fn(fi)
+	return err == nil && fn(fi)
 }
 
 func reqPkg(pkgs map[string]*ast.Package, name string) *ast.Package {

parser/parser_test.go

@@ -27,12 +27,31 @@ import (
 
 // -----------------------------------------------------------------------------
 
+type fileInfo struct {
+	*fsx.FileInfo
+}
+
+func (p fileInfo) Info() (fs.FileInfo, error) {
+	return nil, fs.ErrNotExist
+}
+
 func TestFilter(t *testing.T) {
 	d := fsx.NewFileInfo("foo.go", 10)
 	if filter(d, func(fi fs.FileInfo) bool {
 		return false
 	}) {
-		t.Fatal("TestFilter failed")
+		t.Fatal("TestFilter: true?")
+	}
+	if !filter(d, func(fi fs.FileInfo) bool {
+		return true
+	}) {
+		t.Fatal("TestFilter: false?")
+	}
+	d2 := fileInfo{d}
+	if filter(d2, func(fi fs.FileInfo) bool {
+		return true
+	}) {
+		t.Fatal("TestFilter: true?")
 	}
 }
 

x/typesutil/check.go

@@ -148,7 +148,7 @@ func (p *Checker) Files(goFiles []*goast.File, gopFiles []*ast.File) (err error)
 		LookupPub:      c2go.LookupPub(mod),
 		LookupClass:    mod.LookupClass,
 		Importer:       conf.Importer,
-		Recorder:       gopRecorder{p.gopInfo},
+		Recorder:       NewRecorder(p.gopInfo),
 		NoFileLine:     true,
 		NoAutoGenMain:  true,
 		NoSkipConstant: true,
@@ -169,12 +169,14 @@ func (p *Checker) Files(goFiles []*goast.File, gopFiles []*ast.File) (err error)
 			log.Println("typesutil.Check err:", err)
 			log.SingleStack()
 		}
+		// don't return even if err != nil
 	}
 	if len(files) > 0 {
 		scope := pkgTypes.Scope()
 		objMap := DeleteObjects(scope, files)
 		checker := types.NewChecker(conf, fset, pkgTypes, p.goInfo)
 		err = checker.Files(files)
+		// TODO: how to process error?
 		CorrectTypesInfo(scope, objMap, p.gopInfo.Uses)
 	}
 	return

x/typesutil/gopinfo.go

@@ -20,6 +20,7 @@ import (
 	"go/types"
 
 	"github.com/goplus/gop/ast"
+	"github.com/goplus/gop/cl"
 	"github.com/goplus/gox"
 	"github.com/qiniu/x/log"
 )
@@ -168,6 +169,11 @@ type gopRecorder struct {
 	*Info
 }
 
+// NewRecorder creates a new recorder for cl.NewPackage.
+func NewRecorder(info *Info) cl.Recorder {
+	return gopRecorder{info}
+}
+
 // Type maps expressions to their types, and for constant
 // expressions, also their values. Invalid expressions are
 // omitted.