cl: record builtin

Author: visualfc

Diff for: 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,12 +66,15 @@ 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
 )
 
-var builtinDefs = [...]struct {
+var builtinTypes = [...]struct {
 	name string
 	pkg  string
 	sym  string
@@ -80,6 +84,13 @@ var builtinDefs = [...]struct {
 	{"bigfloat", "github.com/goplus/gop/builtin/ng", ""},
 	{"int128", "github.com/goplus/gop/builtin/ng", ""},
 	{"uint128", "github.com/goplus/gop/builtin/ng", ""},
+}
+
+var builtinFuncs = [...]struct {
+	name string
+	pkg  string
+	sym  string
+}{
 	{"lines", "github.com/goplus/gop/builtin/iox", ""},
 	{"blines", "github.com/goplus/gop/builtin/iox", "BLines"},
 	{"newRange", "github.com/goplus/gop/builtin", "NewRange__0"},
@@ -101,35 +112,46 @@ var builtinDefs = [...]struct {
 type defSym struct {
 	name string
 	sym  string
+	fn   bool
 }
 
 var (
 	builtinSym map[string][]defSym
 )
 
+func insertBuiltin(name, pkg, sym string, fn bool) {
+	if sym == "" {
+		sym = string(name[0]-('a'-'A')) + name[1:]
+	}
+	builtinSym[pkg] = append(builtinSym[pkg], defSym{name: name, sym: sym, fn: fn})
+	obj := &Builtin{name: name, pkg: pkg, sym: sym, fn: fn}
+	Universe.Insert(obj)
+}
+
 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)
+	for _, def := range builtinTypes {
+		insertBuiltin(def.name, def.pkg, def.sym, false)
+	}
+	for _, def := range builtinFuncs {
+		insertBuiltin(def.name, def.pkg, def.sym, true)
 	}
 }
 
-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 +169,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])

Diff for: 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) {
+}

Diff for: 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)
 }
 
 // -----------------------------------------------------------------------------

Diff for: 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
+}

Diff for: 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?")
+	}
 }

Diff for: cl/recorder.go

@@ -32,13 +32,16 @@ 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}
+	builtin := make(map[*ast.Ident]struct{})
+	return &goxRecorder{Recorder: rec, types: types, referDefs: referDefs,
+		referUses: referUses, builtin: builtin}
 }
 
 // Refer uses maps identifiers to name for ast.OverloadFuncDecl.
@@ -127,23 +130,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 +255,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:

Diff for: 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
+	}
+}
+
 // -----------------------------------------------------------------------------