v1.1.9

.github/workflows/go.yml

@@ -10,7 +10,7 @@ jobs:
   Test:
     strategy:
       matrix:
-        go-version: [1.17.x, 1.18.x, 1.19.x, 1.20.x]
+        go-version: [1.18.x, 1.19.x, 1.20.x, 1.21.x]
         os: [ubuntu-latest, windows-latest, macos-11]
     runs-on: ${{ matrix.os }}
     steps:

README.md

@@ -51,7 +51,7 @@ For more details, see [Quick Start](doc/docs.md).
 
 For now, we suggest you install Go+ from source code.
 
-Note: Requires go1.17 or later
+Note: Requires go1.18 or later
 
 ```bash
 git clone https://github.com/goplus/gop.git

ast/ast.go

@@ -1059,6 +1059,7 @@ type (
 		Type     *FuncType     // function signature: parameters, results, and position of "func" keyword
 		Body     *BlockStmt    // function body; or nil for external (non-Go) function
 		Operator bool          // is operator or not
+		Shadow   bool          // is a shadow entry
 	}
 )
 
@@ -1123,7 +1124,7 @@ type FileType = int16
 // are "free-floating" (see also issues #18593, #20744).
 type File struct {
 	Doc     *CommentGroup // associated documentation; or nil
-	Package token.Pos     // position of "package" keyword
+	Package token.Pos     // position of "package" keyword; or NoPos
 	Name    *Ident        // package name
 	Decls   []Decl        // top-level declarations; or nil
 
@@ -1144,8 +1145,18 @@ func (f *File) NoEntrypoint() bool {
 	return f.ShadowEntry != nil
 }
 
+// HasPkgDecl checks if `package xxx` exists or not.
+func (f *File) HasPkgDecl() bool {
+	return f.Package != token.NoPos
+}
+
 // Pos returns position of first character belonging to the node.
-func (f *File) Pos() token.Pos { return f.Package }
+func (f *File) Pos() token.Pos {
+	if f.Package != token.NoPos {
+		return f.Package
+	}
+	return f.Name.NamePos
+}
 
 // End returns position of first character immediately after the node.
 func (f *File) End() token.Pos {

ast/fromgo/gopast.go

@@ -211,9 +211,19 @@ func gopIdent(v *ast.Ident) *gopast.Ident {
 	return &gopast.Ident{
 		NamePos: v.NamePos,
 		Name:    v.Name,
+		Obj:     &gopast.Object{Data: v},
 	}
 }
 
+// CheckIdent checks if a Go+ ast.Ident is converted from a Go ast.Ident or not.
+// If it is, CheckIdent returns the original Go ast.Ident object.
+func CheckIdent(v *gopast.Ident) (id *ast.Ident, ok bool) {
+	if o := v.Obj; o != nil && o.Kind == 0 && o.Data != nil {
+		id, ok = o.Data.(*ast.Ident)
+	}
+	return
+}
+
 func gopIdents(names []*ast.Ident) []*gopast.Ident {
 	ret := make([]*gopast.Ident, len(names))
 	for i, v := range names {
@@ -332,6 +342,7 @@ const (
 	KeepCgo
 )
 
+// ASTFile converts a Go ast.File into a Go+ ast.File object.
 func ASTFile(f *ast.File, mode int) *gopast.File {
 	if (mode & KeepFuncBody) != 0 {
 		log.Panicln("ASTFile: doesn't support keeping func body now")

ast/fromgo/gopast_test.go

@@ -23,6 +23,7 @@ import (
 	"go/token"
 	"testing"
 
+	gopast "github.com/goplus/gop/ast"
 	"github.com/goplus/gop/format"
 )
 
@@ -125,3 +126,14 @@ type foo int
 func (a foo) Str() (string) {}
 `)
 }
+
+func TestCheckIdent(t *testing.T) {
+	if _, ok := CheckIdent(&gopast.Ident{}); ok {
+		t.Fatal("CheckIdent: found?")
+	}
+	if _, ok := CheckIdent(&gopast.Ident{Obj: &gopast.Object{
+		Data: &ast.Ident{},
+	}}); !ok {
+		t.Fatal("CheckIdent: not found?")
+	}
+}

ast/walk.go

@@ -16,7 +16,9 @@
 
 package ast
 
-import "fmt"
+import (
+	"fmt"
+)
 
 // Visitor - A Visitor's Visit method is invoked for each node encountered by Walk.
 // If the result visitor w is not nil, Walk visits each of the children
@@ -59,7 +61,6 @@ func walkDeclList(v Visitor, list []Decl) {
 // v.Visit(node) is not nil, Walk is invoked recursively with visitor
 // w for each of the non-nil children of node, followed by a call of
 // w.Visit(nil).
-//
 func Walk(v Visitor, node Node) {
 	if v = v.Visit(node); v == nil {
 		return
@@ -344,14 +345,16 @@ func Walk(v Visitor, node Node) {
 		}
 
 	case *FuncDecl:
-		if n.Doc != nil {
-			Walk(v, n.Doc)
-		}
-		if n.Recv != nil {
-			Walk(v, n.Recv)
+		if !n.Shadow { // not a shadow entry
+			if n.Doc != nil {
+				Walk(v, n.Doc)
+			}
+			if n.Recv != nil {
+				Walk(v, n.Recv)
+			}
+			Walk(v, n.Name)
+			Walk(v, n.Type)
 		}
-		Walk(v, n.Name)
-		Walk(v, n.Type)
 		if n.Body != nil {
 			Walk(v, n.Body)
 		}
@@ -372,6 +375,62 @@ func Walk(v Visitor, node Node) {
 			Walk(v, f)
 		}
 
+	// Go+ expr and stmt
+	case *SliceLit:
+		walkExprList(v, n.Elts)
+
+	case *LambdaExpr:
+		walkIdentList(v, n.Lhs)
+		walkExprList(v, n.Rhs)
+
+	case *LambdaExpr2:
+		walkIdentList(v, n.Lhs)
+		Walk(v, n.Body)
+
+	case *ForPhrase:
+		if n.Key != nil {
+			Walk(v, n.Key)
+		}
+		if n.Value != nil {
+			Walk(v, n.Value)
+		}
+		if n.Init != nil {
+			Walk(v, n.Init)
+		}
+		if n.Cond != nil {
+			Walk(v, n.Cond)
+		}
+		Walk(v, n.X)
+
+	case *ComprehensionExpr:
+		if n.Elt != nil {
+			Walk(v, n.Elt)
+		}
+		for _, x := range n.Fors {
+			Walk(v, x)
+		}
+
+	case *ForPhraseStmt:
+		Walk(v, n.ForPhrase)
+		Walk(v, n.Body)
+
+	case *RangeExpr:
+		if n.First != nil {
+			Walk(v, n.First)
+		}
+		if n.Last != nil {
+			Walk(v, n.Last)
+		}
+		if n.Expr3 != nil {
+			Walk(v, n.Expr3)
+		}
+
+	case *ErrWrapExpr:
+		Walk(v, n.X)
+		if n.Default != nil {
+			Walk(v, n.Default)
+		}
+
 	default:
 		panic(fmt.Sprintf("ast.Walk: unexpected node type %T", n))
 	}
@@ -392,7 +451,6 @@ func (f inspector) Visit(node Node) Visitor {
 // f(node); node must not be nil. If f returns true, Inspect invokes f
 // recursively for each of the non-nil children of node, followed by a
 // call of f(nil).
-//
 func Inspect(node Node, f func(Node) bool) {
 	Walk(inspector(f), node)
 }

build_install_run.go

@@ -86,8 +86,8 @@ func BuildPkgPath(workDir, pkgPath string, conf *Config, build *gocmd.BuildConfi
 	if err != nil {
 		return errors.NewWith(err, `GenGoPkgPath(workDir, pkgPath, conf, false)`, -2, "gop.GenGoPkgPath", workDir, pkgPath, conf, false)
 	}
-	old := chdirAndMod(localDir)
-	defer restoreDirAndMod(old)
+	old, mod := chdirAndMod(localDir)
+	defer restoreDirAndMod(old, mod)
 	return gocmd.Build(cwdParam(recursively), build)
 }
 
@@ -99,13 +99,18 @@ func BuildFiles(files []string, conf *Config, build *gocmd.BuildConfig) (err err
 	return gocmd.BuildFiles(files, build)
 }
 
-func chdirAndMod(dir string) string {
+func chdirAndMod(dir string) (old string, mod os.FileMode) {
+	mod = 0755
+	if info, err := os.Stat(dir); err == nil {
+		mod = info.Mode().Perm()
+	}
 	os.Chmod(dir, 0777)
-	return chdir(dir)
+	old = chdir(dir)
+	return
 }
 
-func restoreDirAndMod(old string) {
-	os.Chmod(".", 0555)
+func restoreDirAndMod(old string, mod os.FileMode) {
+	os.Chmod(".", mod)
 	os.Chdir(old)
 }
 
@@ -158,8 +163,8 @@ func TestPkgPath(workDir, pkgPath string, conf *Config, test *gocmd.TestConfig)
 	if err != nil {
 		return errors.NewWith(err, `GenGoPkgPath(workDir, pkgPath, conf, false)`, -2, "gop.GenGoPkgPath", workDir, pkgPath, conf, false)
 	}
-	old := chdirAndMod(localDir)
-	defer restoreDirAndMod(old)
+	old, mod := chdirAndMod(localDir)
+	defer restoreDirAndMod(old, mod)
 	return gocmd.Test(cwdParam(recursively), test)
 }
 

cl/builtin.go

@@ -41,39 +41,51 @@ func initBuiltinFns(builtin *types.Package, scope *types.Scope, pkg *gox.PkgRef,
 
 func initBuiltin(pkg *gox.Package, builtin *types.Package, os, fmt, ng, iox, buil *gox.PkgRef) {
 	scope := builtin.Scope()
-	typs := []string{"bigint", "bigrat", "bigfloat"}
-	for _, typ := range typs {
-		name := string(typ[0]-('a'-'A')) + typ[1:]
-		scope.Insert(types.NewTypeName(token.NoPos, builtin, typ, ng.Ref(name).Type()))
+	if ng != nil {
+		typs := []string{"bigint", "bigrat", "bigfloat"}
+		for _, typ := range typs {
+			name := string(typ[0]-('a'-'A')) + typ[1:]
+			scope.Insert(types.NewTypeName(token.NoPos, builtin, typ, ng.Ref(name).Type()))
+		}
+		scope.Insert(types.NewTypeName(token.NoPos, builtin, "uint128", ng.Ref("Uint128").Type()))
+		scope.Insert(types.NewTypeName(token.NoPos, builtin, "int128", ng.Ref("Int128").Type()))
+	}
+	if fmt != nil {
+		initBuiltinFns(builtin, scope, fmt, []string{
+			"print", "println", "printf", "errorf",
+			"fprint", "fprintln", "fprintf",
+			"sprint", "sprintln", "sprintf",
+		})
+	}
+	if os != nil {
+		initBuiltinFns(builtin, scope, os, []string{
+			"open", "create",
+		})
+	}
+	if iox != nil {
+		initBuiltinFns(builtin, scope, iox, []string{
+			"lines",
+		})
+		scope.Insert(gox.NewOverloadFunc(token.NoPos, builtin, "blines", iox.Ref("BLines")))
+	}
+	if buil != nil {
+		scope.Insert(gox.NewOverloadFunc(token.NoPos, builtin, "newRange", buil.Ref("NewRange__0")))
 	}
-	initBuiltinFns(builtin, scope, fmt, []string{
-		"print", "println", "printf", "errorf",
-		"fprint", "fprintln", "fprintf",
-		"sprint", "sprintln", "sprintf",
-	})
-	initBuiltinFns(builtin, scope, os, []string{
-		"open", "create",
-	})
-	initBuiltinFns(builtin, scope, iox, []string{
-		"lines",
-	})
-	scope.Insert(gox.NewOverloadFunc(token.NoPos, builtin, "blines", iox.Ref("BLines")))
-	scope.Insert(gox.NewOverloadFunc(token.NoPos, builtin, "newRange", buil.Ref("NewRange__0")))
-	scope.Insert(types.NewTypeName(token.NoPos, builtin, "uint128", ng.Ref("Uint128").Type()))
-	scope.Insert(types.NewTypeName(token.NoPos, builtin, "int128", ng.Ref("Int128").Type()))
 	scope.Insert(types.NewTypeName(token.NoPos, builtin, "any", gox.TyEmptyInterface))
 }
 
 func newBuiltinDefault(pkg *gox.Package, conf *gox.Config) *types.Package {
 	builtin := types.NewPackage("", "")
-	fmt := pkg.Import("fmt")
-	os := pkg.Import("os")
-	buil := pkg.Import("github.com/goplus/gop/builtin")
-	ng := pkg.Import("github.com/goplus/gop/builtin/ng")
-	iox := pkg.Import("github.com/goplus/gop/builtin/iox")
-	pkg.Import("strconv")
-	pkg.Import("strings")
-	initMathBig(pkg, conf, ng)
+	fmt := pkg.TryImport("fmt")
+	os := pkg.TryImport("os")
+	buil := pkg.TryImport("github.com/goplus/gop/builtin")
+	ng := pkg.TryImport("github.com/goplus/gop/builtin/ng")
+	iox := pkg.TryImport("github.com/goplus/gop/builtin/iox")
+	pkg.TryImport("strconv")
+	pkg.TryImport("strings")
+	if ng != nil {
+		initMathBig(pkg, conf, ng)
+	}
 	initBuiltin(pkg, builtin, os, fmt, ng, iox, buil)
 	gox.InitBuiltin(pkg, builtin, conf)
 	return builtin