Giant blob of minor changes

[dotfiles/.git] / .config / coc / extensions / coc-go-data / tools / pkg / mod / golang.org / x / tools@v0.0.0-20201028153306-37f0764111ff / cmd / bundle / main.go

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Bundle creates a single-source-file version of a source package
// suitable for inclusion in a particular target package.
//
// Usage:
//
//      bundle [-o file] [-dst path] [-pkg name] [-prefix p] [-import old=new] [-tags build_constraints] <src>
//
// The src argument specifies the import path of the package to bundle.
// The bundling of a directory of source files into a single source file
// necessarily imposes a number of constraints.
// The package being bundled must not use cgo; must not use conditional
// file compilation, whether with build tags or system-specific file names
// like code_amd64.go; must not depend on any special comments, which
// may not be preserved; must not use any assembly sources;
// must not use renaming imports; and must not use reflection-based APIs
// that depend on the specific names of types or struct fields.
//
// By default, bundle writes the bundled code to standard output.
// If the -o argument is given, bundle writes to the named file
// and also includes a ``//go:generate'' comment giving the exact
// command line used, for regenerating the file with ``go generate.''
//
// Bundle customizes its output for inclusion in a particular package, the destination package.
// By default bundle assumes the destination is the package in the current directory,
// but the destination package can be specified explicitly using the -dst option,
// which takes an import path as its argument.
// If the source package imports the destination package, bundle will remove
// those imports and rewrite any references to use direct references to the
// corresponding symbols.
// Bundle also must write a package declaration in the output and must
// choose a name to use in that declaration.
// If the -pkg option is given, bundle uses that name.
// Otherwise, the name of the destination package is used.
// Build constraints for the generated file can be specified using the -tags option.
//
// To avoid collisions, bundle inserts a prefix at the beginning of
// every package-level const, func, type, and var identifier in src's code,
// updating references accordingly. The default prefix is the package name
// of the source package followed by an underscore. The -prefix option
// specifies an alternate prefix.
//
// Occasionally it is necessary to rewrite imports during the bundling
// process. The -import option, which may be repeated, specifies that
// an import of "old" should be rewritten to import "new" instead.
//
// Example
//
// Bundle archive/zip for inclusion in cmd/dist:
//
//      cd $GOROOT/src/cmd/dist
//      bundle -o zip.go archive/zip
//
// Bundle golang.org/x/net/http2 for inclusion in net/http,
// prefixing all identifiers by "http2" instead of "http2_", and
// including a "!nethttpomithttp2" build constraint:
//
//      cd $GOROOT/src/net/http
//      bundle -o h2_bundle.go -prefix http2 -tags '!nethttpomithttp2' golang.org/x/net/http2
//
// Update the http2 bundle in net/http:
//
//      go generate net/http
//
// Update all bundles in the standard library:
//
//      go generate -run bundle std
//
package main

import (
        "bytes"
        "flag"
        "fmt"
        "go/ast"
        "go/format"
        "go/printer"
        "go/token"
        "go/types"
        "io/ioutil"
        "log"
        "os"
        "strconv"
        "strings"

        "golang.org/x/tools/go/packages"
)

var (
        outputFile = flag.String("o", "", "write output to `file` (default standard output)")
        dstPath    = flag.String("dst", ".", "set destination import `path`")
        pkgName    = flag.String("pkg", "", "set destination package `name`")
        prefix     = flag.String("prefix", "&_", "set bundled identifier prefix to `p` (default is \"&_\", where & stands for the original name)")
        buildTags  = flag.String("tags", "", "the build constraints to be inserted into the generated file")

        importMap = map[string]string{}
)

func init() {
        flag.Var(flagFunc(addImportMap), "import", "rewrite import using `map`, of form old=new (can be repeated)")
}

func addImportMap(s string) {
        if strings.Count(s, "=") != 1 {
                log.Fatal("-import argument must be of the form old=new")
        }
        i := strings.Index(s, "=")
        old, new := s[:i], s[i+1:]
        if old == "" || new == "" {
                log.Fatal("-import argument must be of the form old=new; old and new must be non-empty")
        }
        importMap[old] = new
}

func usage() {
        fmt.Fprintf(os.Stderr, "Usage: bundle [options] <src>\n")
        flag.PrintDefaults()
}

func main() {
        log.SetPrefix("bundle: ")
        log.SetFlags(0)

        flag.Usage = usage
        flag.Parse()
        args := flag.Args()
        if len(args) != 1 {
                usage()
                os.Exit(2)
        }

        cfg := &packages.Config{Mode: packages.NeedName}
        pkgs, err := packages.Load(cfg, *dstPath)
        if err != nil {
                log.Fatalf("cannot load destination package: %v", err)
        }
        if packages.PrintErrors(pkgs) > 0 || len(pkgs) != 1 {
                log.Fatalf("failed to load destination package")
        }
        if *pkgName == "" {
                *pkgName = pkgs[0].Name
        }

        code, err := bundle(args[0], pkgs[0].PkgPath, *pkgName, *prefix, *buildTags)
        if err != nil {
                log.Fatal(err)
        }
        if *outputFile != "" {
                err := ioutil.WriteFile(*outputFile, code, 0666)
                if err != nil {
                        log.Fatal(err)
                }
        } else {
                _, err := os.Stdout.Write(code)
                if err != nil {
                        log.Fatal(err)
                }
        }
}

// isStandardImportPath is copied from cmd/go in the standard library.
func isStandardImportPath(path string) bool {
        i := strings.Index(path, "/")
        if i < 0 {
                i = len(path)
        }
        elem := path[:i]
        return !strings.Contains(elem, ".")
}

var testingOnlyPackagesConfig *packages.Config

func bundle(src, dst, dstpkg, prefix, buildTags string) ([]byte, error) {
        // Load the initial package.
        cfg := &packages.Config{}
        if testingOnlyPackagesConfig != nil {
                *cfg = *testingOnlyPackagesConfig
        } else {
                // Bypass default vendor mode, as we need a package not available in the
                // std module vendor folder.
                cfg.Env = append(os.Environ(), "GOFLAGS=-mod=mod")
        }
        cfg.Mode = packages.NeedTypes | packages.NeedSyntax | packages.NeedTypesInfo
        pkgs, err := packages.Load(cfg, src)
        if err != nil {
                return nil, err
        }
        if packages.PrintErrors(pkgs) > 0 || len(pkgs) != 1 {
                return nil, fmt.Errorf("failed to load source package")
        }
        pkg := pkgs[0]

        if strings.Contains(prefix, "&") {
                prefix = strings.Replace(prefix, "&", pkg.Syntax[0].Name.Name, -1)
        }

        objsToUpdate := make(map[types.Object]bool)
        var rename func(from types.Object)
        rename = func(from types.Object) {
                if !objsToUpdate[from] {
                        objsToUpdate[from] = true

                        // Renaming a type that is used as an embedded field
                        // requires renaming the field too. e.g.
                        //      type T int // if we rename this to U..
                        //      var s struct {T}
                        //      print(s.T) // ...this must change too
                        if _, ok := from.(*types.TypeName); ok {
                                for id, obj := range pkg.TypesInfo.Uses {
                                        if obj == from {
                                                if field := pkg.TypesInfo.Defs[id]; field != nil {
                                                        rename(field)
                                                }
                                        }
                                }
                        }
                }
        }

        // Rename each package-level object.
        scope := pkg.Types.Scope()
        for _, name := range scope.Names() {
                rename(scope.Lookup(name))
        }

        var out bytes.Buffer
        if buildTags != "" {
                fmt.Fprintf(&out, "// +build %s\n\n", buildTags)
        }

        fmt.Fprintf(&out, "// Code generated by golang.org/x/tools/cmd/bundle. DO NOT EDIT.\n")
        if *outputFile != "" && buildTags == "" {
                fmt.Fprintf(&out, "//go:generate bundle %s\n", strings.Join(os.Args[1:], " "))
        } else {
                fmt.Fprintf(&out, "//   $ bundle %s\n", strings.Join(os.Args[1:], " "))
        }
        fmt.Fprintf(&out, "\n")

        // Concatenate package comments from all files...
        for _, f := range pkg.Syntax {
                if doc := f.Doc.Text(); strings.TrimSpace(doc) != "" {
                        for _, line := range strings.Split(doc, "\n") {
                                fmt.Fprintf(&out, "// %s\n", line)
                        }
                }
        }
        // ...but don't let them become the actual package comment.
        fmt.Fprintln(&out)

        fmt.Fprintf(&out, "package %s\n\n", dstpkg)

        // BUG(adonovan,shurcooL): bundle may generate incorrect code
        // due to shadowing between identifiers and imported package names.
        //
        // The generated code will either fail to compile or
        // (unlikely) compile successfully but have different behavior
        // than the original package. The risk of this happening is higher
        // when the original package has renamed imports (they're typically
        // renamed in order to resolve a shadow inside that particular .go file).

        // TODO(adonovan,shurcooL):
        // - detect shadowing issues, and either return error or resolve them
        // - preserve comments from the original import declarations.

        // pkgStd and pkgExt are sets of printed import specs. This is done
        // to deduplicate instances of the same import name and path.
        var pkgStd = make(map[string]bool)
        var pkgExt = make(map[string]bool)
        for _, f := range pkg.Syntax {
                for _, imp := range f.Imports {
                        path, err := strconv.Unquote(imp.Path.Value)
                        if err != nil {
                                log.Fatalf("invalid import path string: %v", err) // Shouldn't happen here since packages.Load succeeded.
                        }
                        if path == dst {
                                continue
                        }
                        if newPath, ok := importMap[path]; ok {
                                path = newPath
                        }

                        var name string
                        if imp.Name != nil {
                                name = imp.Name.Name
                        }
                        spec := fmt.Sprintf("%s %q", name, path)
                        if isStandardImportPath(path) {
                                pkgStd[spec] = true
                        } else {
                                pkgExt[spec] = true
                        }
                }
        }

        // Print a single declaration that imports all necessary packages.
        fmt.Fprintln(&out, "import (")
        for p := range pkgStd {
                fmt.Fprintf(&out, "\t%s\n", p)
        }
        if len(pkgExt) > 0 {
                fmt.Fprintln(&out)
        }
        for p := range pkgExt {
                fmt.Fprintf(&out, "\t%s\n", p)
        }
        fmt.Fprint(&out, ")\n\n")

        // Modify and print each file.
        for _, f := range pkg.Syntax {
                // Update renamed identifiers.
                for id, obj := range pkg.TypesInfo.Defs {
                        if objsToUpdate[obj] {
                                id.Name = prefix + obj.Name()
                        }
                }
                for id, obj := range pkg.TypesInfo.Uses {
                        if objsToUpdate[obj] {
                                id.Name = prefix + obj.Name()
                        }
                }

                // For each qualified identifier that refers to the
                // destination package, remove the qualifier.
                // The "@@@." strings are removed in postprocessing.
                ast.Inspect(f, func(n ast.Node) bool {
                        if sel, ok := n.(*ast.SelectorExpr); ok {
                                if id, ok := sel.X.(*ast.Ident); ok {
                                        if obj, ok := pkg.TypesInfo.Uses[id].(*types.PkgName); ok {
                                                if obj.Imported().Path() == dst {
                                                        id.Name = "@@@"
                                                }
                                        }
                                }
                        }
                        return true
                })

                last := f.Package
                if len(f.Imports) > 0 {
                        imp := f.Imports[len(f.Imports)-1]
                        last = imp.End()
                        if imp.Comment != nil {
                                if e := imp.Comment.End(); e > last {
                                        last = e
                                }
                        }
                }

                // Pretty-print package-level declarations.
                // but no package or import declarations.
                var buf bytes.Buffer
                for _, decl := range f.Decls {
                        if decl, ok := decl.(*ast.GenDecl); ok && decl.Tok == token.IMPORT {
                                continue
                        }

                        beg, end := sourceRange(decl)

                        printComments(&out, f.Comments, last, beg)

                        buf.Reset()
                        format.Node(&buf, pkg.Fset, &printer.CommentedNode{Node: decl, Comments: f.Comments})
                        // Remove each "@@@." in the output.
                        // TODO(adonovan): not hygienic.
                        out.Write(bytes.Replace(buf.Bytes(), []byte("@@@."), nil, -1))

                        last = printSameLineComment(&out, f.Comments, pkg.Fset, end)

                        out.WriteString("\n\n")
                }

                printLastComments(&out, f.Comments, last)
        }

        // Now format the entire thing.
        result, err := format.Source(out.Bytes())
        if err != nil {
                log.Fatalf("formatting failed: %v", err)
        }

        return result, nil
}

// sourceRange returns the [beg, end) interval of source code
// belonging to decl (incl. associated comments).
func sourceRange(decl ast.Decl) (beg, end token.Pos) {
        beg = decl.Pos()
        end = decl.End()

        var doc, com *ast.CommentGroup

        switch d := decl.(type) {
        case *ast.GenDecl:
                doc = d.Doc
                if len(d.Specs) > 0 {
                        switch spec := d.Specs[len(d.Specs)-1].(type) {
                        case *ast.ValueSpec:
                                com = spec.Comment
                        case *ast.TypeSpec:
                                com = spec.Comment
                        }
                }
        case *ast.FuncDecl:
                doc = d.Doc
        }

        if doc != nil {
                beg = doc.Pos()
        }
        if com != nil && com.End() > end {
                end = com.End()
        }

        return beg, end
}

func printComments(out *bytes.Buffer, comments []*ast.CommentGroup, pos, end token.Pos) {
        for _, cg := range comments {
                if pos <= cg.Pos() && cg.Pos() < end {
                        for _, c := range cg.List {
                                fmt.Fprintln(out, c.Text)
                        }
                        fmt.Fprintln(out)
                }
        }
}

const infinity = 1 << 30

func printLastComments(out *bytes.Buffer, comments []*ast.CommentGroup, pos token.Pos) {
        printComments(out, comments, pos, infinity)
}

func printSameLineComment(out *bytes.Buffer, comments []*ast.CommentGroup, fset *token.FileSet, pos token.Pos) token.Pos {
        tf := fset.File(pos)
        for _, cg := range comments {
                if pos <= cg.Pos() && tf.Line(cg.Pos()) == tf.Line(pos) {
                        for _, c := range cg.List {
                                fmt.Fprintln(out, c.Text)
                        }
                        return cg.End()
                }
        }
        return pos
}

type flagFunc func(string)

func (f flagFunc) Set(s string) error {
        f(s)
        return nil
}

func (f flagFunc) String() string { return "" }