cl: universe scope

Author: visualfc

Diff for: cl/builtin.go

@@ -31,68 +31,123 @@ func initMathBig(_ *gogen.Package, conf *gogen.Config, big gogen.PkgRef) {
 	conf.UntypedBigFloat = big.Ref("UntypedBigfloat").Type().(*types.Named)
 }
 
-func initBuiltinFns(builtin *types.Package, scope *types.Scope, pkg gogen.PkgRef, fns []string) {
-	for _, fn := range fns {
-		fnTitle := string(fn[0]-'a'+'A') + fn[1:]
-		scope.Insert(gogen.NewOverloadFunc(token.NoPos, builtin, fn, pkg.Ref(fnTitle)))
+type Builtin struct {
+	types.Object
+	name string
+	pkg  string
+	sym  string
+}
+
+func (t *Builtin) Parent() *types.Scope {
+	return Universe
+}
+func (t *Builtin) Pos() token.Pos {
+	return token.NoPos
+}
+func (t *Builtin) Pkg() *types.Package {
+	return nil
+}
+func (t *Builtin) Name() string {
+	return t.name
+}
+func (t *Builtin) Type() types.Type {
+	return types.Typ[types.Invalid]
+}
+func (t *Builtin) Exported() bool {
+	return false
+}
+func (t *Builtin) Id() string {
+	return "_." + t.name
+}
+func (t *Builtin) String() string {
+	return "builtin " + t.name
+}
+func (t *Builtin) Sym() string {
+	return t.pkg + "." + t.sym
+}
+
+var (
+	Universe *types.Scope
+)
+
+var builtinDefs = [...]struct {
+	name string
+	pkg  string
+	sym  string
+}{
+	{"bigint", "github.com/goplus/gop/builtin/ng", ""},
+	{"bigrat", "github.com/goplus/gop/builtin/ng", ""},
+	{"bigfloat", "github.com/goplus/gop/builtin/ng", ""},
+	{"int128", "github.com/goplus/gop/builtin/ng", ""},
+	{"uint128", "github.com/goplus/gop/builtin/ng", ""},
+	{"lines", "github.com/goplus/gop/builtin/iox", ""},
+	{"blines", "github.com/goplus/gop/builtin/iox", "BLines"},
+	{"newRange", "github.com/goplus/gop/builtin", "NewRange__0"},
+	{"echo", "fmt", "Println"},
+	{"print", "fmt", ""},
+	{"println", "fmt", ""},
+	{"printf", "fmt", ""},
+	{"errorf", "fmt", ""},
+	{"fprint", "fmt", ""},
+	{"fprintln", "fmt", ""},
+	{"sprint", "fmt", ""},
+	{"sprintln", "fmt", ""},
+	{"sprintf", "fmt", ""},
+	{"open", "os", ""},
+	{"create", "os", ""},
+	{"type", "reflect", "TypeOf"},
+}
+
+type defSym struct {
+	name string
+	sym  string
+}
+
+var (
+	builtinSym map[string][]defSym
+)
+
+func init() {
+	Universe = types.NewScope(nil, 0, 0, "universe")
+	builtinSym = make(map[string][]defSym)
+	for _, def := range builtinDefs {
+		if def.sym == "" {
+			def.sym = string(def.name[0]-('a'-'A')) + def.name[1:]
+		}
+		builtinSym[def.pkg] = append(builtinSym[def.pkg], defSym{name: def.name, sym: def.sym})
+		obj := &Builtin{name: def.name, pkg: def.pkg, sym: def.sym}
+		Universe.Insert(obj)
 	}
 }
 
-func initBuiltin(_ *gogen.Package, builtin *types.Package, os, fmt, ng, iox, buil, reflect gogen.PkgRef) {
+func initBuiltin(pkg *gogen.Package, builtin *types.Package) {
 	scope := builtin.Scope()
-	if ng.Types != 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()))
+	for im, defs := range builtinSym {
+		if p := pkg.TryImport(im); p.Types != nil {
+			for _, def := range defs {
+				obj := p.Ref(def.sym)
+				if _, ok := obj.Type().(*types.Named); ok {
+					scope.Insert(types.NewTypeName(token.NoPos, builtin, def.name, obj.Type()))
+				} else {
+					scope.Insert(gogen.NewOverloadFunc(token.NoPos, builtin, def.name, obj))
+				}
+			}
 		}
-		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.Types != nil {
-		scope.Insert(gogen.NewOverloadFunc(token.NoPos, builtin, "echo", fmt.Ref("Println")))
-		initBuiltinFns(builtin, scope, fmt, []string{
-			"print", "println", "printf", "errorf",
-			"fprint", "fprintln", "fprintf",
-			"sprint", "sprintln", "sprintf",
-		})
-	}
-	if os.Types != nil {
-		initBuiltinFns(builtin, scope, os, []string{
-			"open", "create",
-		})
-	}
-	if iox.Types != nil {
-		initBuiltinFns(builtin, scope, iox, []string{
-			"lines",
-		})
-		scope.Insert(gogen.NewOverloadFunc(token.NoPos, builtin, "blines", iox.Ref("BLines")))
-	}
-	if reflect.Types != nil {
-		scope.Insert(gogen.NewOverloadFunc(token.NoPos, builtin, "type", reflect.Ref("TypeOf")))
-	}
-	if buil.Types != nil {
-		scope.Insert(gogen.NewOverloadFunc(token.NoPos, builtin, "newRange", buil.Ref("NewRange__0")))
 	}
 	scope.Insert(types.NewTypeName(token.NoPos, builtin, "any", gogen.TyEmptyInterface))
 }
 
 func newBuiltinDefault(pkg *gogen.Package, conf *gogen.Config) *types.Package {
 	builtin := types.NewPackage("", "")
-	fmt := pkg.TryImport("fmt")
-	os := pkg.TryImport("os")
-	reflect := pkg.TryImport("reflect")
-	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")
 	strx := pkg.TryImport("github.com/qiniu/x/stringutil")
 	stringslice := pkg.TryImport("github.com/goplus/gop/builtin/stringslice")
 	pkg.TryImport("strconv")
 	pkg.TryImport("strings")
 	if ng.Types != nil {
 		initMathBig(pkg, conf, ng)
 	}
-	initBuiltin(pkg, builtin, os, fmt, ng, iox, buil, reflect)
+	initBuiltin(pkg, builtin)
 	gogen.InitBuiltin(pkg, builtin, conf)
 	if strx.Types != nil {
 		ti := pkg.BuiltinTI(types.Typ[types.String])

Diff for: cl/builtin_test.go

@@ -603,4 +603,35 @@ func TestClassFileEnd(t *testing.T) {
 	}
 }
 
+func TestUniverse(t *testing.T) {
+	echo := Universe.Lookup("echo")
+	if echo == nil {
+		t.Fatal("not found")
+	}
+	if echo.Parent() != Universe {
+		t.Fatal("bad parent")
+	}
+	if echo.Pos() != token.NoPos {
+		t.Fatal("must nopos")
+	}
+	if echo.Pkg() != nil {
+		t.Fatal("must nil")
+	}
+	if echo.Type() != types.Typ[types.Invalid] {
+		t.Fatal("must invalid")
+	}
+	if echo.Name() != "echo" {
+		t.Fatal("bad name")
+	}
+	if echo.Id() != "_.echo" {
+		t.Fatal("bad id")
+	}
+	if echo.String() != "builtin echo" {
+		t.Fatal("bad string")
+	}
+	if b, ok := echo.(*Builtin); !ok || b.Sym() != "fmt.Println" {
+		t.Fatal("bad sym")
+	}
+}
+
 // -----------------------------------------------------------------------------