// Track imports simplifies all imports into a single large package
// with mangled names. In the process, it drops functions that are
// never referred to.
func TrackImports(pkgs map[string](map[string]*ast.File)) (main *ast.File) {
// Let's first set of the package we're going to generate...
main = new(ast.File)
main.Name = ast.NewIdent("main")
initstmts := []ast.Stmt{} // this is where we'll stash the init statements...
todo := make(map[string]struct{})
todo["main.init"] = struct{}{}
todo["main.main"] = struct{}{}
done := make(map[string]struct{})
for len(todo) > 0 {
for pkgfn := range todo {
pkg := splitLast(pkgfn, ".")[0] // FIXME: Need to split after last "." only
fn := splitLast(pkgfn, ".")[1]
fmt.Println("Working on", fn, "in", pkg)
if _, ok := done[pkg+".init"]; !ok && fn != "init" {
// We still need to init this package!
todo[pkg+".init"] = struct{}{}
}
// fmt.Println("Working on package", pkg, "function", fn)
// We need to look in all this package's files...
for _, f := range pkgs[pkg] {
// FIXME: it'd be marginally faster to first check if the
// function we want is in this particular file. On the other
// hand, when there's only one file per package, that would be
// slower...
// First we'll track down the import declarations...
sc := PackageScoping{
Imports: make(map[string]string),
Globals: make(map[string]string),
}
for _, d := range f.Decls {
if i, ok := d.(*ast.GenDecl); ok && i.Tok == token.IMPORT {
for _, s := range i.Specs {
ispec := s.(*ast.ImportSpec) // This should always be okay!
path, _ := strconv.Unquote(string(ispec.Path.Value))
name := path
if ispec.Name != nil {
name = ispec.Name.Name
} else {
for _, f := range pkgs[path] {
name = f.Name.Name
}
}
sc.Imports[name] = path
}
} else if vdecl, ok := d.(*ast.GenDecl); ok && vdecl.Tok == token.VAR {
for _, spec0 := range vdecl.Specs {
spec := spec0.(*ast.ValueSpec)
for _, n := range spec.Names {
sc.Globals[n.Name] = pkg
}
}
} else if tdecl, ok := d.(*ast.GenDecl); ok && vdecl.Tok == token.TYPE {
for _, spec0 := range tdecl.Specs {
spec := spec0.(*ast.TypeSpec)
sc.Globals[spec.Name.Name] = pkg
}
} else if fdecl, ok := d.(*ast.FuncDecl); ok {
sc.Globals[fdecl.Name.Name] = pkg
}
}
// Now we'll go ahead and mangle things...
for _, d := range f.Decls {
if cdecl, ok := d.(*ast.GenDecl); ok && cdecl.Tok == token.CONST {
fmt.Println("FIXME: I don't handle const yet at all... (ignoring)")
} else if tdecl, ok := d.(*ast.GenDecl); ok && tdecl.Tok == token.TYPE {
for _, spec0 := range tdecl.Specs {
spec := spec0.(*ast.TypeSpec)
if spec.Name.Name == fn {
// fmt.Println("Got type declaration of", spec.Name)
spec := *spec
spec.Name = ast.NewIdent(fn)
spec.Type = sc.MangleExpr(spec.Type)
sc.MangleExpr(spec.Name)
d := &ast.GenDecl{
Tok: token.TYPE,
Specs: []ast.Spec{&spec},
}
main.Decls = append(main.Decls, d)
}
}
} else if vdecl, ok := d.(*ast.GenDecl); ok && vdecl.Tok == token.VAR {
for _, spec0 := range vdecl.Specs {
spec := spec0.(*ast.ValueSpec)
for i, n := range spec.Names {
if n.Name == fn {
// fmt.Println("I got variable", fn)
nnew := *n
sc.MangleExpr(&nnew)
vs := []ast.Expr(nil)
if len(spec.Values) > i {
vs = append(vs, spec.Values[i])
sc.MangleExpr(spec.Values[i])
}
sc.MangleExpr(spec.Type)
d := ast.GenDecl{
Tok: token.VAR,
Specs: []ast.Spec{
&ast.ValueSpec{
Names: []*ast.Ident{&nnew},
Type: spec.Type,
Values: vs,
},
},
}
main.Decls = append(main.Decls, &d)
}
}
}
} else if fdecl, ok := d.(*ast.FuncDecl); ok {
if fdecl.Name.Name == fn {
// first, let's update the name... but in a copy of the
// function declaration
fdecl := *fdecl
fdecl.Name = ast.NewIdent(pkg + "_" + fn)
if fdecl.Type.Params != nil {
for _, f := range fdecl.Type.Params.List {
sc.MangleExpr(f.Type)
}
}
if fdecl.Type.Results != nil {
for _, f := range fdecl.Type.Results.List {
sc.MangleExpr(f.Type)
}
}
sc.MangleStatement(fdecl.Body)
// fmt.Println("Dumping out", pkg, fn)
main.Decls = append(main.Decls, &fdecl)
if fn == "init" && fdecl.Recv == nil {
initstmts = append(initstmts,
&ast.ExprStmt{&ast.CallExpr{Fun: fdecl.Name}})
}
}
}
}
// See what else we need to compile...
for _, x := range sc.ToDo {
if _, done := done[x]; !done {
todo[x] = struct{}{}
}
}
}
delete(todo, pkgfn)
done[pkgfn] = struct{}{}
}
}
// Now we reverse the order, so that the declarations will be in
// C-style order, not requiring forward declarations.
newdecls := make([]ast.Decl, len(main.Decls))
for i := range main.Decls {
newdecls[i] = main.Decls[len(main.Decls)-i-1]
}
main.Decls = newdecls
mainfn := new(ast.FuncDecl)
mainfn.Name = ast.NewIdent("main")
mainfn.Type = &ast.FuncType{Params: &ast.FieldList{}}
initstmts = append(initstmts,
&ast.ExprStmt{&ast.CallExpr{Fun: ast.NewIdent("main_main")}})
mainfn.Body = &ast.BlockStmt{List: initstmts}
main.Decls = append(main.Decls, mainfn)
return main
}
