cl: record builtin

Author: visualfc

cl/builtin.go

@@ -36,6 +36,7 @@ type Builtin struct {
 	name string
 	pkg  string
 	sym  string
+	fn   bool
 }
 
 func (t *Builtin) Parent() *types.Scope {
@@ -65,6 +66,9 @@ func (t *Builtin) String() string {
 func (t *Builtin) Sym() string {
 	return t.pkg + "." + t.sym
 }
+func (t *Builtin) IsFunc() bool {
+	return t.fn
+}
 
 var (
 	Universe *types.Scope
@@ -74,33 +78,35 @@ var builtinDefs = [...]struct {
 	name string
 	pkg  string
 	sym  string
+	fn   bool
 }{
-	{"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"},
+	{"bigint", "github.com/goplus/gop/builtin/ng", "", false},
+	{"bigrat", "github.com/goplus/gop/builtin/ng", "", false},
+	{"bigfloat", "github.com/goplus/gop/builtin/ng", "", false},
+	{"int128", "github.com/goplus/gop/builtin/ng", "", false},
+	{"uint128", "github.com/goplus/gop/builtin/ng", "", false},
+	{"lines", "github.com/goplus/gop/builtin/iox", "", true},
+	{"blines", "github.com/goplus/gop/builtin/iox", "BLines", true},
+	{"newRange", "github.com/goplus/gop/builtin", "NewRange__0", true},
+	{"echo", "fmt", "Println", true},
+	{"print", "fmt", "", true},
+	{"println", "fmt", "", true},
+	{"printf", "fmt", "", true},
+	{"errorf", "fmt", "", true},
+	{"fprint", "fmt", "", true},
+	{"fprintln", "fmt", "", true},
+	{"sprint", "fmt", "", true},
+	{"sprintln", "fmt", "", true},
+	{"sprintf", "fmt", "", true},
+	{"open", "os", "", true},
+	{"create", "os", "", true},
+	{"type", "reflect", "TypeOf", true},
 }
 
 type defSym struct {
 	name string
 	sym  string
+	fn   bool
 }
 
 var (
@@ -114,22 +120,25 @@ func init() {
 		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}
+		builtinSym[def.pkg] = append(builtinSym[def.pkg], defSym{name: def.name, sym: def.sym, fn: def.fn})
+		obj := &Builtin{name: def.name, pkg: def.pkg, sym: def.sym, fn: def.fn}
 		Universe.Insert(obj)
 	}
 }
 
-func initBuiltin(pkg *gogen.Package, builtin *types.Package) {
+func initBuiltin(pkg *gogen.Package, builtin *types.Package, conf *gogen.Config) {
 	scope := builtin.Scope()
 	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 {
+				if def.fn {
 					scope.Insert(gogen.NewOverloadFunc(token.NoPos, builtin, def.name, obj))
+				} else {
+					scope.Insert(types.NewTypeName(token.NoPos, builtin, def.name, obj.Type()))
+				}
+				if rec, ok := conf.Recorder.(*goxRecorder); ok {
+					rec.Builtin(def.name, obj)
 				}
 			}
 		}
@@ -147,7 +156,7 @@ func newBuiltinDefault(pkg *gogen.Package, conf *gogen.Config) *types.Package {
 	if ng.Types != nil {
 		initMathBig(pkg, conf, ng)
 	}
-	initBuiltin(pkg, builtin)
+	initBuiltin(pkg, builtin, conf)
 	gogen.InitBuiltin(pkg, builtin, conf)
 	if strx.Types != nil {
 		ti := pkg.BuiltinTI(types.Typ[types.String])

cl/cltest/recorder.go

@@ -121,3 +121,6 @@ func (info gopRecorder) Select(e *ast.SelectorExpr, sel *types.Selection) {
 //	*ast.RangeStmt
 func (info gopRecorder) Scope(n ast.Node, scope *types.Scope) {
 }
+
+func (info gopRecorder) Builtin(name string, obj types.Object) {
+}

cl/compile.go

@@ -163,6 +163,9 @@ type Recorder interface {
 	//     *ast.LambdaExpr2
 	//
 	Scope(ast.Node, *types.Scope)
+
+	// Go+ builtin name object
+	Builtin(name string, obj types.Object)
 }
 
 // -----------------------------------------------------------------------------

cl/internal/typesutil/api.go

@@ -114,3 +114,9 @@ func NewTypeAndValueForObject(obj types.Object) (ret types.TypeAndValue) {
 	(*TypeAndValue)(unsafe.Pointer(&ret)).mode = mode
 	return
 }
+
+func NewTypeAndValueForBuiltin(obj types.Object) (ret types.TypeAndValue) {
+	ret.Type = obj.Type()
+	(*TypeAndValue)(unsafe.Pointer(&ret)).mode = Builtin
+	return
+}

cl/internal/typesutil/api_test.go

@@ -80,4 +80,8 @@ func TestTypeAndValue(t *testing.T) {
 	if !ret.IsBuiltin() {
 		t.Fatal("NewTypeAndValueForObject: not builtin?")
 	}
+	ret = NewTypeAndValueForBuiltin(types.Universe.Lookup("len"))
+	if !ret.IsBuiltin() {
+		t.Fatal("NewTypeAndValueForObject: not builtin?")
+	}
 }

cl/recorder.go

@@ -32,13 +32,15 @@ type goxRecorder struct {
 	types     map[ast.Expr]types.TypeAndValue
 	referDefs map[*ast.Ident]ast.Node
 	referUses map[string][]*ast.Ident
+	builtin   map[*ast.Ident]struct{}
 }
 
 func newRecorder(rec Recorder) *goxRecorder {
 	types := make(map[ast.Expr]types.TypeAndValue)
 	referDefs := make(map[*ast.Ident]ast.Node)
 	referUses := make(map[string][]*ast.Ident)
-	return &goxRecorder{rec, types, referDefs, referUses}
+	return &goxRecorder{Recorder: rec, types: types, referDefs: referDefs, referUses: referUses,
+		builtin: make(map[*ast.Ident]struct{})}
 }
 
 // Refer uses maps identifiers to name for ast.OverloadFuncDecl.
@@ -127,23 +129,22 @@ func (p *goxRecorder) Member(id ast.Node, obj types.Object) {
 			p.Type(v, tv)
 		}
 	case *ast.Ident: // it's in a classfile and impossible converted from Go
-		p.Use(v, obj)
-		p.Type(v, typesutil.NewTypeAndValueForObject(obj))
+		p.recordIdent(v, obj)
 	}
 }
 
 func (p *goxRecorder) Call(id ast.Node, obj types.Object) {
 	switch v := id.(type) {
 	case *ast.Ident:
-		p.Use(v, obj)
-		p.Type(v, typesutil.NewTypeAndValueForObject(obj))
+		p.recordIdent(v, obj)
 	case *ast.SelectorExpr:
 		p.Use(v.Sel, obj)
 		p.Type(v, typesutil.NewTypeAndValueForObject(obj))
 	case *ast.CallExpr:
 		switch id := v.Fun.(type) {
 		case *ast.Ident:
-			p.Use(id, obj)
+			p.recordIdent(id, obj)
+			return
 		case *ast.SelectorExpr:
 			p.Use(id.Sel, obj)
 		}
@@ -253,10 +254,36 @@ func (rec *goxRecorder) recordType(typ ast.Expr, t types.Type) {
 }
 
 func (rec *goxRecorder) recordIdent(ident *ast.Ident, obj types.Object) {
+	if _, ok := rec.builtin[ident]; ok {
+		return
+	}
+	if o, ok := isBuiltinFunc(ident, obj); ok {
+		rec.builtin[ident] = struct{}{}
+		rec.Use(ident, o)
+		rec.Type(ident, typesutil.NewTypeAndValueForBuiltin(o))
+		return
+	}
 	rec.Use(ident, obj)
 	rec.Type(ident, typesutil.NewTypeAndValueForObject(obj))
 }
 
+func isBuiltinFunc(ident *ast.Ident, obj types.Object) (types.Object, bool) {
+	if pkg := obj.Pkg(); pkg == nil || (pkg.Path() == "" && pkg.Name() == "") {
+		if o := Universe.Lookup(ident.Name); o != nil && o.(*Builtin).IsFunc() {
+			return o, true
+		}
+		switch ident.Name {
+		case "append", "cap", "clear", "close", "complex", "copy",
+			"delete", "imag", "len", "make", "max", "min", "new",
+			"panic", "real", "recover":
+			if o := types.Universe.Lookup(ident.Name); o != nil {
+				return o, true
+			}
+		}
+	}
+	return nil, false
+}
+
 func (rec *goxRecorder) recordExpr(ctx *blockCtx, expr ast.Expr, _ bool) {
 	switch v := expr.(type) {
 	case *ast.Ident:

x/typesutil/gopinfo.go

@@ -138,6 +138,9 @@ type Info struct {
 
 	// Overloads maps identifiers to the overload decl object.
 	Overloads map[*ast.Ident]types.Object
+
+	// Builtins maps identifiers the Go+ builtin name object.
+	Builtins map[string]types.Object
 }
 
 // ObjectOf returns the object denoted by the specified id,
@@ -188,6 +191,9 @@ type gopRecorder struct {
 
 // NewRecorder creates a new recorder for cl.NewPackage.
 func NewRecorder(info *Info) cl.Recorder {
+	if info == nil {
+		return nil
+	}
 	return gopRecorder{info}
 }
 
@@ -334,4 +340,11 @@ func (info gopRecorder) Scope(n ast.Node, scope *types.Scope) {
 	}
 }
 
+// Go+ builtin name object
+func (info gopRecorder) Builtin(name string, obj types.Object) {
+	if info.Builtins != nil {
+		info.Builtins[name] = obj
+	}
+}
+
 // -----------------------------------------------------------------------------