split up loading of package from parsing, only use the tools packages.Load and remove dependence on GOPATH GoSrcDir -- should now work exclusively with modules. also only build but don't install packages so go/bin doesn't get spammed

Author: Randall C. O'Reilly

bind/symbols.go

@@ -564,6 +564,10 @@ func (sym *symtab) addSymbol(obj types.Object) error {
 		}
 
 	case *types.TypeName:
+		// tn := obj.(*types.TypeName)
+		// if tn.IsAlias() {
+		// 	fmt.Printf("type is an alias: %v\n", tn)
+		// }
 		return sym.addType(obj, obj.Type())
 
 	default:

cmd_build.go

@@ -66,13 +66,17 @@ func gopyRunCmdBuild(cmdr *commander.Command, args []string) error {
 	cmdstr := argStr()
 
 	for _, path := range args {
-		pkg, err := newPackage(path)
+		bpkg, err := loadPackage(path, true) // build first
 		if err != nil {
-			return fmt.Errorf("gopy-build: go/build.Import failed with path=%q: %v", path, err)
+			return fmt.Errorf("gopy-gen: go build / load of package failed with path=%q: %v", path, err)
 		}
+		pkg, err := parsePackage(bpkg)
 		if name == "" {
 			name = pkg.Name()
 		}
+		if err != nil {
+			return err
+		}
 	}
 	return runBuild("build", odir, name, cmdstr, vm, mainstr, symbols)
 }

cmd_exe.go

@@ -122,17 +122,7 @@ func gopyRunCmdExe(cmdr *commander.Command, args []string) error {
 	}
 
 	for _, path := range args {
-		var rootdir string
-		var err error
-		if strings.HasPrefix(path, "./") {
-			rootdir = path
-		} else {
-			rootdir, err = GoSrcDir(path)
-		}
-		if err != nil {
-			return err
-		}
-		buildPkgRecurse(odir, path, rootdir, rootdir, exmap)
+		buildPkgRecurse(odir, path, path, exmap)
 	}
 	return runBuild(bind.ModeExe, odir, name, cmdstr, vm, mainstr, symbols)
 }

cmd_gen.go

@@ -65,16 +65,19 @@ func gopyRunCmdGen(cmdr *commander.Command, args []string) error {
 	bind.NoMake = nomake
 
 	for _, path := range args {
-		pkg, err := newPackage(path)
+		bpkg, err := loadPackage(path, true) // build first
+		if err != nil {
+			return fmt.Errorf("gopy-gen: go build / load of package failed with path=%q: %v", path, err)
+		}
+		pkg, err := parsePackage(bpkg)
 		if name == "" {
 			name = pkg.Name()
 		}
 		if err != nil {
-			return fmt.Errorf("gopy-gen: go/build.Import failed with path=%q: %v", path, err)
+			return err
 		}
 	}
 
-	// false = library version
 	err = genPkg(bind.ModeGen, odir, name, cmdstr, vm, mainstr)
 	if err != nil {
 		return err

cmd_pkg.go

@@ -120,44 +120,44 @@ func gopyRunCmdPkg(cmdr *commander.Command, args []string) error {
 	}
 
 	for _, path := range args {
-		var rootdir string
-		var err error
-		if strings.HasPrefix(path, "./") {
-			rootdir = path
-		} else {
-			rootdir, err = GoSrcDir(path)
-		}
-		if err != nil {
-			return err
-		}
-		buildPkgRecurse(odir, path, rootdir, rootdir, exmap)
+		buildPkgRecurse(odir, path, path, exmap)
 	}
 	return runBuild(bind.ModePkg, odir, name, cmdstr, vm, mainstr, symbols)
 }
 
-func buildPkgRecurse(odir, path, rootdir, pathdir string, exmap map[string]struct{}) {
-	reldir, _ := filepath.Rel(rootdir, pathdir)
-	gofiles := GoFiles(pathdir)
-	// fmt.Printf("go files: %s\n", gofiles)
+func buildPkgRecurse(odir, path, rootpath string, exmap map[string]struct{}) error {
+	buildFirst := path == rootpath
+	bpkg, err := loadPackage(path, buildFirst)
+	if err != nil {
+		return fmt.Errorf("gopy-gen: go build / load of package failed with path=%q: %v", path, err)
+	}
+	gofiles := bpkg.GoFiles
 	if len(gofiles) == 0 || (len(gofiles) == 1 && gofiles[0] == "doc.go") {
-		fmt.Printf("\tskipping dir with no go files or only doc.go file: %s -- %s\n", pathdir, gofiles)
-	} else {
-		if reldir == "" {
-			newPackage(path)
-		} else {
-			pkgpath := path + "/" + reldir
-			newPackage(pkgpath)
+		fmt.Printf("\tskipping dir with no go files or only doc.go file: %s -- %s\n", path, gofiles)
+		if len(gofiles) == 0 {
+			// fmt.Printf("otherfiles: %v\nignorefiles: %v\n", bpkg.OtherFiles, bpkg.IgnoredFiles)
+			if len(bpkg.OtherFiles) > 0 {
+				gofiles = bpkg.OtherFiles
+			} else if len(bpkg.IgnoredFiles) > 0 {
+				gofiles = bpkg.IgnoredFiles
+			} else {
+				return nil // done
+			}
 		}
+	} else {
+		parsePackage(bpkg)
 	}
 
 	//	now try all subdirs
-	drs := Dirs(pathdir)
+	dir, _ := filepath.Split(gofiles[0])
+	drs := Dirs(dir)
 	for _, dr := range drs {
 		_, ex := exmap[dr]
 		if ex || dr[0] == '.' || dr[0] == '_' {
 			continue
 		}
-		sp := filepath.Join(pathdir, dr)
-		buildPkgRecurse(odir, path, rootdir, sp, exmap)
+		sp := filepath.Join(path, dr)
+		buildPkgRecurse(odir, sp, rootpath, exmap)
 	}
+	return nil
 }

dirs.go

@@ -5,27 +5,9 @@
 package main
 
 import (
-	"fmt"
-	"go/build"
 	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strings"
 )
 
-// GoSrcDir tries to locate dir in GOPATH/src/ or GOROOT/src/pkg/ and returns its
-// full path. GOPATH may contain a list of paths.  From Robin Elkind github.com/mewkiz/pkg
-func GoSrcDir(dir string) (absDir string, err error) {
-	for _, srcDir := range build.Default.SrcDirs() {
-		absDir = filepath.Join(srcDir, dir)
-		finfo, err := os.Stat(absDir)
-		if err == nil && finfo.IsDir() {
-			return absDir, nil
-		}
-	}
-	return "", fmt.Errorf("GoSrcDir: unable to locate directory (%q) in GOPATH/src/ (%q) or GOROOT/src/pkg/ (%q)", dir, os.Getenv("GOPATH"), os.Getenv("GOROOT"))
-}
-
 // Dirs returns a slice of all the directories within a given directory
 func Dirs(path string) []string {
 	files, err := ioutil.ReadDir(path)
@@ -41,19 +23,3 @@ func Dirs(path string) []string {
 	}
 	return fnms
 }
-
-// GoFiles returns a slice of all the go files within a given directory
-func GoFiles(path string) []string {
-	files, err := ioutil.ReadDir(path)
-	if err != nil {
-		return nil
-	}
-
-	var fnms []string
-	for _, fi := range files {
-		if !fi.IsDir() && strings.HasSuffix(fi.Name(), ".go") {
-			fnms = append(fnms, fi.Name())
-		}
-	}
-	return fnms
-}

gen.go

@@ -85,28 +85,30 @@ func genPkg(mode bind.BuildMode, odir, outname, cmdstr, vm, mainstr string) erro
 	return err
 }
 
-func newPackage(path string) (*bind.Package, error) {
+func loadPackage(path string, buildFirst bool) (*packages.Package, error) {
 	cwd, err := os.Getwd()
 	if err != nil {
 		return nil, err
 	}
 
-	cmd := exec.Command("go", "install", path)
-	cmd.Stdin = os.Stdin
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	cmd.Dir = cwd
+	if buildFirst {
+		cmd := exec.Command("go", "build", "-v", path)
+		cmd.Stdin = os.Stdin
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		cmd.Dir = cwd
 
-	err = cmd.Run()
-	if err != nil {
-		log.Printf("error installing [%s]: %v\n",
-			path,
-			err,
-		)
-		return nil, err
+		err = cmd.Run()
+		if err != nil {
+			log.Printf("error building [%s]: %v\n",
+				path,
+				err,
+			)
+			return nil, err
+		}
 	}
 
-	// golang.org/x/tools/go/packages supports loading of std library packages too
+	// golang.org/x/tools/go/packages supports modules or GOPATH etc
 	bpkgs, err := packages.Load(&packages.Config{Mode: packages.LoadTypes}, path)
 	if err != nil {
 		log.Printf("error resolving import path [%s]: %v\n",
@@ -117,11 +119,15 @@ func newPackage(path string) (*bind.Package, error) {
 	}
 
 	bpkg := bpkgs[0] // only ever have one at a time
+	return bpkg, nil
+}
+
+func parsePackage(bpkg *packages.Package) (*bind.Package, error) {
 	dir, _ := filepath.Split(bpkg.GoFiles[0])
 	p := bpkg.Types
 
 	if bpkg.Name == "main" {
-		err = fmt.Errorf("gopy: skipping 'main' package %q", bpkg.PkgPath)
+		err := fmt.Errorf("gopy: skipping 'main' package %q", bpkg.PkgPath)
 		fmt.Println(err)
 		return nil, err
 	}

go.mod

@@ -1,10 +1,11 @@
 module github.com/go-python/gopy
 
-go 1.12
+go 1.13
 
 require (
+	github.com/goki/gide v1.0.10 // indirect
 	github.com/gonuts/commander v0.1.0
 	github.com/gonuts/flag v0.1.0
-	github.com/pkg/errors v0.8.1
-	golang.org/x/tools v0.0.0-20200326194725-b1df9901287c
+	github.com/pkg/errors v0.9.1
+	golang.org/x/tools v0.0.0-20201123232213-4aa1a224cdb5
 )