OverloadFunc

cl/builtin_test.go

@@ -53,6 +53,65 @@ func TestErrStringLit(t *testing.T) {
 	})
 }
 
+func TestErrPreloadFile(t *testing.T) {
+	pkg := gox.NewPackage("", "foo", goxConf)
+	ctx := &blockCtx{pkgCtx: &pkgCtx{}}
+	func() {
+		defer func() {
+			if e := recover(); e == nil || e != "TODO - OverloadFuncDecl\n" {
+				t.Fatal("TestErrPreloadFile:", e)
+			}
+		}()
+		decls := []ast.Decl{
+			&ast.OverloadFuncDecl{
+				Name: &ast.Ident{Name: "add"},
+				Funcs: []ast.Expr{
+					&ast.FuncLit{},
+				},
+				Operator: true,
+			},
+		}
+		preloadFile(pkg, ctx, "foo.gop", &ast.File{Decls: decls}, "", true)
+	}()
+	func() {
+		defer func() {
+			if e := recover(); e == nil || e != "TODO - cl.preloadFile OverloadFuncDecl: unknown func - *ast.BasicLit\n" {
+				t.Fatal("TestErrPreloadFile:", e)
+			}
+		}()
+		decls := []ast.Decl{
+			&ast.OverloadFuncDecl{
+				Name: &ast.Ident{Name: "add"},
+				Funcs: []ast.Expr{
+					&ast.BasicLit{},
+				},
+				Operator: true,
+			},
+		}
+		preloadFile(pkg, ctx, "foo.gop", &ast.File{Decls: decls}, "", true)
+	}()
+	func() {
+		defer func() {
+			if e := recover(); e == nil || e != "TODO - cl.preloadFile: unknown decl - *ast.BadDecl\n" {
+				t.Fatal("TestErrPreloadFile:", e)
+			}
+		}()
+		decls := []ast.Decl{
+			&ast.BadDecl{},
+		}
+		preloadFile(pkg, ctx, "foo.gop", &ast.File{Decls: decls}, "", true)
+	}()
+}
+
+func TestErrParseTypeEmbedName(t *testing.T) {
+	defer func() {
+		if e := recover(); e == nil {
+			t.Fatal("TestErrParseTypeEmbedName: no panic?")
+		}
+	}()
+	parseTypeEmbedName(&ast.StructType{})
+}
+
 func TestGmxMainFunc(t *testing.T) {
 	gmxMainFunc(nil, &pkgCtx{
 		projs: map[string]*gmxProject{

cl/compile.go

@@ -24,6 +24,7 @@
 	"log"
 	"reflect"
 	"sort"
+	"strconv"
 	"strings"
 	_ "unsafe"
 
@@ -344,6 +345,7 @@
 	fset    *token.FileSet
 	cpkgs   *cpackages.Importer
 	syms    map[string]loader
+	ovnames []string // names should load before initGopPkg
 	inits   []func()
 	tylds   []*typeLoader
 	errs    errors.List
@@ -642,6 +644,9 @@
 			ctx.loadSymbol(name)
 		}
 	}
+	for _, name := range ctx.ovnames {
+		ctx.loadSymbol(name)
+	}
 	if pkg.Types.Scope().Lookup(gopPackage) == nil {
 		pkg.Types.Scope().Insert(types.NewConst(token.NoPos, pkg.Types, gopPackage, types.Typ[types.UntypedBool], constant.MakeBool(true)))
 	}
@@ -664,17 +669,6 @@
 func loadFile(ctx *pkgCtx, f *ast.File) {
 	for _, decl := range f.Decls {
 		switch d := decl.(type) {
-		case *ast.FuncDecl:
-			if d.Recv == nil {
-				name := d.Name.Name
-				if name != "init" {
-					ctx.loadSymbol(name)
-				}
-			} else {
-				if name, ok := getRecvTypeName(ctx, d.Recv, false); ok {
-					getTypeLoader(ctx, ctx.syms, token.NoPos, name).load()
-				}
-			}
 		case *ast.GenDecl:
 			switch d.Tok {
 			case token.TYPE:
@@ -688,6 +682,27 @@
 					}
 				}
 			}
+		case *ast.FuncDecl:
+			if d.Recv == nil {
+				name := d.Name.Name
+				if name != "init" {
+					ctx.loadSymbol(name)
+				}
+			} else {
+				if name, ok := getRecvTypeName(ctx, d.Recv, false); ok {
+					getTypeLoader(ctx, ctx.syms, token.NoPos, name).load()
+				}
+			}
+		case *ast.OverloadFuncDecl:
+			/* name := d.Name
+			for idx, fn := range d.Funcs {
+				switch expr := fn.(type) {
+				case *ast.FuncLit:
+					// ctx.loadSymbol(overloadFuncName(name.Name, idx))
+				default:
+					log.Panicf("TODO - cl.loadFile OverloadFuncDecl: unknown func - %T\n", expr)
+				}
+			} */
 		}
 	}
 }
@@ -891,51 +906,75 @@
 	if f.IsClass {
 		skipClassFields = true
 	}
-	for _, decl := range f.Decls {
-		switch d := decl.(type) {
-		case *ast.FuncDecl:
-			if ctx.classRecv != nil { // in class file (.spx/.gmx)
-				if d.Recv == nil {
-					d.Recv = ctx.classRecv
-					d.IsClass = true
+
+	preloadFuncDecl := func(d *ast.FuncDecl) {
+		if ctx.classRecv != nil { // in class file (.spx/.gmx)
+			if d.Recv == nil {
+				d.Recv = ctx.classRecv
+				d.IsClass = true
+			}
+		}
+		if d.Recv == nil {
+			name := d.Name
+			fn := func() {
+				old, _ := p.SetCurFile(goFile, true)
+				defer p.RestoreCurFile(old)
+				loadFunc(ctx, nil, d, genFnBody)
+			}
+			if name.Name == "init" {
+				if genFnBody {
+					if debugLoad {
+						log.Println("==> Preload func init")
+					}
+					parent.inits = append(parent.inits, fn)
+				}
+			} else {
+				if debugLoad {
+					log.Println("==> Preload func", name.Name)
 				}
+				initLoader(parent, syms, name.Pos(), name.Name, fn, genFnBody)
 			}
-			if d.Recv == nil {
-				name := d.Name
+		} else {
+			if name, ok := getRecvTypeName(parent, d.Recv, true); ok {
+				if debugLoad {
+					log.Printf("==> Preload method %s.%s\n", name, d.Name.Name)
+				}
+				ld := getTypeLoader(parent, syms, token.NoPos, name)
 				fn := func() {
 					old, _ := p.SetCurFile(goFile, true)
 					defer p.RestoreCurFile(old)
-					loadFunc(ctx, nil, d, genFnBody)
-				}
-				if name.Name == "init" {
-					if genFnBody {
-						if debugLoad {
-							log.Println("==> Preload func init")
-						}
-						parent.inits = append(parent.inits, fn)
-					}
-				} else {
-					if debugLoad {
-						log.Println("==> Preload func", name.Name)
-					}
-					initLoader(parent, syms, name.Pos(), name.Name, fn, genFnBody)
+					doInitType(ld)
+					recv := toRecv(ctx, d.Recv)
+					loadFunc(ctx, recv, d, genFnBody)
 				}
-			} else {
-				if name, ok := getRecvTypeName(parent, d.Recv, true); ok {
-					if debugLoad {
-						log.Printf("==> Preload method %s.%s\n", name, d.Name.Name)
-					}
-					ld := getTypeLoader(parent, syms, token.NoPos, name)
-					fn := func() {
-						old, _ := p.SetCurFile(goFile, true)
-						defer p.RestoreCurFile(old)
-						doInitType(ld)
-						recv := toRecv(ctx, d.Recv)
-						loadFunc(ctx, recv, d, genFnBody)
+				ld.methods = append(ld.methods, fn)
+			}
+		}
+	}
+
+	preloadConst := func(d *ast.GenDecl) {
+		pkg := ctx.pkg
+		cdecl := pkg.NewConstDefs(pkg.Types.Scope())
+		for _, spec := range d.Specs {
+			vSpec := spec.(*ast.ValueSpec)
+			if debugLoad {
+				log.Println("==> Preload const", vSpec.Names)
+			}
+			setNamesLoader(parent, syms, vSpec.Names, func() {
+				if c := cdecl; c != nil {
+					cdecl = nil
+					loadConstSpecs(ctx, c, d.Specs)
+					for _, s := range d.Specs {
+						v := s.(*ast.ValueSpec)
+						removeNames(syms, v.Names)
 					}
-					ld.methods = append(ld.methods, fn)
 				}
-			}
+			})
+		}
+	}
+
+	for _, decl := range f.Decls {
+		switch d := decl.(type) {
 		case *ast.GenDecl:
 			switch d.Tok {
 			case token.IMPORT:
@@ -1009,24 +1048,7 @@
 					}
 				}
 			case token.CONST:
-				pkg := ctx.pkg
-				cdecl := pkg.NewConstDefs(pkg.Types.Scope())
-				for _, spec := range d.Specs {
-					vSpec := spec.(*ast.ValueSpec)
-					if debugLoad {
-						log.Println("==> Preload const", vSpec.Names)
-					}
-					setNamesLoader(parent, syms, vSpec.Names, func() {
-						if c := cdecl; c != nil {
-							cdecl = nil
-							loadConstSpecs(ctx, c, d.Specs)
-							for _, s := range d.Specs {
-								v := s.(*ast.ValueSpec)
-								removeNames(syms, v.Names)
-							}
-						}
-					})
-				}
+				preloadConst(d)
 			case token.VAR:
 				if skipClassFields {
 					skipClassFields = false
@@ -1050,12 +1072,84 @@
 			default:
 				log.Panicln("TODO - tok:", d.Tok, "spec:", reflect.TypeOf(d.Specs).Elem())
 			}
+
+		case *ast.FuncDecl:
+			preloadFuncDecl(d)
+
+		case *ast.OverloadFuncDecl:
+			const (
+				markIdent = 1 << iota
+				markSelector
+				markFuncLit
+			)
+			onames := make([]string, 0, 4)
+			mark := 0
+			name := d.Name
+			for idx, fn := range d.Funcs {
+				switch expr := fn.(type) {
+				case *ast.Ident:
+					onames = append(onames, expr.Name)
+					ctx.ovnames = append(ctx.ovnames, expr.Name)
+					mark |= markIdent
+				case *ast.FuncLit:
+					if d.Recv != nil || d.Operator {
+						log.Panicln("TODO - OverloadFuncDecl")
+					}
+					name1 := overloadFuncName(name.Name, idx)
+					ctx.ovnames = append(ctx.ovnames, name1)
+					preloadFuncDecl(&ast.FuncDecl{
+						Doc:  d.Doc,
+						Name: &ast.Ident{NamePos: name.NamePos, Name: name1},
+						Type: expr.Type,
+						Body: expr.Body,
+					})
+					mark |= markFuncLit
+				default:
+					log.Panicf("TODO - cl.preloadFile OverloadFuncDecl: unknown func - %T\n", expr)
+				}
+			}
+			if (mark & (markIdent | markSelector)) != 0 {
+				oname := overloadName(name.Name)
+				oval := strings.Join(onames, ",")
+				preloadConst(&ast.GenDecl{
+					Doc: d.Doc,
+					Tok: token.CONST,
+					Specs: []ast.Spec{
+						&ast.ValueSpec{
+							Names:  []*ast.Ident{{Name: oname}},
+							Values: []ast.Expr{stringLit(oval)},
+						},
+					},
+				})
+				ctx.ovnames = append(ctx.ovnames, oname)
+			}
+
 		default:
-			log.Panicln("TODO - gopkg.Package.load: unknown decl -", reflect.TypeOf(decl))
+			log.Panicf("TODO - cl.preloadFile: unknown decl - %T\n", decl)
 		}
 	}
 }
 
+const (
+	indexTable = "0123456789abcdefghijklmnopqrstuvwxyz"
+)
+
+func overloadFuncName(name string, idx int) string {
+	return name + "__" + indexTable[idx:idx+1]
+}
+
+func overloadName(name string) string {
+	prefix := "Gopo_"
+	if strings.ContainsRune(name, '_') {
+		prefix = "Gopo__"
+	}
+	return prefix + name
+}
+
+func stringLit(val string) *ast.BasicLit {
+	return &ast.BasicLit{Kind: token.STRING, Value: strconv.Quote(val)}
+}
+
 func newType(pkg *types.Package, pos token.Pos, name string) *types.Named {
 	typName := types.NewTypeName(pos, pkg, name, nil)
 	if old := pkg.Scope().Insert(typName); old != nil {