pax_global_header00006660000000000000000000000064146570407220014521gustar00rootroot0000000000000052 comment=984331f1ee19d6d15173b5d087560edd7b4efe53 golang-honnef-go-tools-2024.1/000077500000000000000000000000001465704072200160745ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/.gitattributes000066400000000000000000000000611465704072200207640ustar00rootroot00000000000000*.golden -text *.svg binary **/testdata/** -text golang-honnef-go-tools-2024.1/.github/000077500000000000000000000000001465704072200174345ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/.github/FUNDING.yml000066400000000000000000000000431465704072200212460ustar00rootroot00000000000000patreon: dominikh github: dominikh golang-honnef-go-tools-2024.1/.github/ISSUE_TEMPLATE/000077500000000000000000000000001465704072200216175ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/.github/ISSUE_TEMPLATE/1_false_positive.md000066400000000000000000000012021465704072200253700ustar00rootroot00000000000000--- name: 💢 False positive in Staticcheck about: Your code is fine but Staticcheck complains about it, anyway. labels: false-positive, needs-triage title: "" --- golang-honnef-go-tools-2024.1/.github/ISSUE_TEMPLATE/2_false_negative.md000066400000000000000000000012021465704072200253310ustar00rootroot00000000000000--- name: 🦆 False negative in Staticcheck about: Your code is wrong but Staticcheck doesn't complain about it. labels: false-negative, needs-triage title: "" --- golang-honnef-go-tools-2024.1/.github/ISSUE_TEMPLATE/3_bug.md000066400000000000000000000011561465704072200231430ustar00rootroot00000000000000--- name: 🐞 General bugs with Staticcheck about: Something in Staticcheck isn't working as it should. labels: bug, needs-triage title: "" --- golang-honnef-go-tools-2024.1/.github/ISSUE_TEMPLATE/4_other.md000066400000000000000000000002201465704072200234770ustar00rootroot00000000000000--- name: 🛠 Other about: Ideas, feature requests, and all other issues not fitting into another category. labels: needs-triage title: "" --- golang-honnef-go-tools-2024.1/.github/ISSUE_TEMPLATE/config.yml000066400000000000000000000000341465704072200236040ustar00rootroot00000000000000blank_issues_enabled: false golang-honnef-go-tools-2024.1/.github/workflows/000077500000000000000000000000001465704072200214715ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/.github/workflows/ci.yml000066400000000000000000000033611465704072200226120ustar00rootroot00000000000000name: "CI" on: ["push", "pull_request"] jobs: ci: name: "Run CI" strategy: fail-fast: false matrix: os: ["windows-latest", "ubuntu-latest", "macOS-latest"] go: ["1.22.x"] godebug: ["gotypesalias=0", "gotypesalias=1"] runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v1 with: fetch-depth: 1 - uses: WillAbides/setup-go-faster@v1.14.0 with: go-version: ${{ matrix.go }} - run: "go test ./..." env: GODEBUG: ${{ matrix.godebug }} - run: "go vet ./..." - uses: dominikh/staticcheck-action@v1 with: version: "2023.1.7" min-go-version: "module" install-go: false cache-key: ${{ matrix.go }} output-format: binary output-file: "./staticcheck.bin" - uses: actions/upload-artifact@v3 with: name: "staticcheck-${{ github.sha }}-${{ matrix.go }}-${{ matrix.os }}.bin" path: "./staticcheck.bin" retention-days: 1 if-no-files-found: warn output: name: "Output Staticcheck findings" needs: ci runs-on: "ubuntu-latest" steps: - uses: WillAbides/setup-go-faster@v1.14.0 with: go-version: "stable" # this downloads all artifacts of the current workflow into the current working directory, creating one directory per artifact - uses: actions/download-artifact@v3 - id: glob run: | # We replace newlines with %0A, which GitHub apparently magically turns back into newlines out=$(ls -1 ./staticcheck-*.bin/*.bin) echo "::set-output name=files::${out//$'\n'/%0A}" - uses: dominikh/staticcheck-action@v1 with: install-go: false merge-files: ${{ steps.glob.outputs.files }} golang-honnef-go-tools-2024.1/.gitignore000066400000000000000000000007211465704072200200640ustar00rootroot00000000000000/cmd/keyify/keyify /cmd/staticcheck/staticcheck /cmd/structlayout-optimize/structlayout-optimize /cmd/structlayout-pretty/structlayout-pretty /cmd/structlayout/structlayout /dist/20??.?.?/ /dist/20??.?/ /internal/cmd/irdump/irdump /website/.hugo_build.lock /website/public /website/resources /website/assets/img/sponsors /website/data/sponsors.toml /website/data/copyrights.toml /website/data/checks.json /website/content/docs/configuration/default_config/index.md golang-honnef-go-tools-2024.1/.gitmodules000066400000000000000000000001471465704072200202530ustar00rootroot00000000000000[submodule "website/themes/docsy"] path = website/themes/docsy url = https://github.com/google/docsy golang-honnef-go-tools-2024.1/LICENSE000066400000000000000000000020421465704072200170770ustar00rootroot00000000000000Copyright (c) 2016 Dominik Honnef Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. golang-honnef-go-tools-2024.1/LICENSE-THIRD-PARTY000066400000000000000000000144521465704072200206540ustar00rootroot00000000000000Staticcheck and its related tools make use of third party projects, either by reusing their code, or by statically linking them into resulting binaries. These projects are: * The Go Programming Language - https://golang.org/ golang.org/x/mod - https://github.com/golang/mod golang.org/x/tools - https://github.com/golang/tools golang.org/x/sys - https://github.com/golang/sys golang.org/x/xerrors - https://github.com/golang/xerrors Copyright (c) 2009 The Go Authors. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Google Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * github.com/BurntSushi/toml - https://github.com/BurntSushi/toml The MIT License (MIT) Copyright (c) 2013 TOML authors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * gogrep - https://github.com/mvdan/gogrep Copyright (c) 2017, Daniel Martí. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * gosmith - https://github.com/dvyukov/gosmith Copyright (c) 2014 Dmitry Vyukov. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * The name of Dmitry Vyukov may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. golang-honnef-go-tools-2024.1/README.md000066400000000000000000000056211465704072200173570ustar00rootroot00000000000000

Staticcheck logo
The advanced Go linter

Staticcheck is a state of the art linter for the [Go programming language](https://go.dev/). Using static analysis, it finds bugs and performance issues, offers simplifications, and enforces style rules. **Financial support by [private and corporate sponsors](https://staticcheck.dev/sponsors) guarantees the tool's continued development. Please [become a sponsor](https://github.com/users/dominikh/sponsorship) if you or your company rely on Staticcheck.** ## Documentation You can find extensive documentation on Staticcheck on [its website](https://staticcheck.dev/docs/). ## Installation ### Releases It is recommended that you run released versions of the tools. These releases can be found as git tags (e.g. `2022.1`). The easiest way of installing a release is by using `go install`, for example `go install honnef.co/go/tools/cmd/staticcheck@2022.1`. Alternatively, we also offer [prebuilt binaries](https://github.com/dominikh/go-tools/releases). You can find more information about installation and releases in the [documentation](https://staticcheck.dev/docs/getting-started/). ### Master You can also run the master branch instead of a release. Note that while the master branch is usually stable, it may still contain new checks or backwards incompatible changes that break your build. By using the master branch you agree to become a beta tester. ## Tools All of the following tools can be found in the cmd/ directory. Each tool is accompanied by its own README, describing it in more detail. | Tool | Description | |----------------------------------------------------|-------------------------------------------------------------------------| | [staticcheck](cmd/staticcheck/) | Go static analysis, detecting bugs, performance issues, and much more. | | [structlayout](cmd/structlayout/) | Displays the layout (field sizes and padding) of structs. | | [structlayout-optimize](cmd/structlayout-optimize) | Reorders struct fields to minimize the amount of padding. | | [structlayout-pretty](cmd/structlayout-pretty) | Formats the output of structlayout with ASCII art. | ## Libraries In addition to the aforementioned tools, this repository contains the libraries necessary to implement these tools. Unless otherwise noted, none of these libraries have stable APIs. Their main purpose is to aid the implementation of the tools. You'll have to expect semiregular backwards-incompatible changes if you decide to use these libraries. ## System requirements Staticcheck can be compiled and run with the latest release of Go. It can analyze code targeting any version of Go upto the latest release. golang-honnef-go-tools-2024.1/_benchmarks/000077500000000000000000000000001465704072200203505ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/_benchmarks/bench.sh000077500000000000000000000026011465704072200217650ustar00rootroot00000000000000#!/usr/bin/env bash set -e declare -A PKGS=( ["strconv"]="strconv" ["net/http"]="net/http" ["image/color"]="image/color" ["std"]="std" ["k8s"]="k8s.io/kubernetes/pkg/..." ) MIN_CORES=32 MAX_CORES=32 INCR_CORES=2 MIN_GOGC=100 MAX_GOGC=100 SAMPLES=10 WIPE_CACHE=1 FORMAT=bench BIN=$(realpath ./silent-staticcheck.sh) runBenchmark() { local pkg="$1" local label="$2" local gc="$3" local cores="$4" local wipe="$5" if [ $wipe -ne 0 ]; then rm -rf ~/.cache/staticcheck fi local out=$(GOGC=$gc GOMAXPROCS=$cores env time -f "%e %M" $BIN $pkg 2>&1) local t=$(echo "$out" | cut -f1 -d" ") local m=$(echo "$out" | cut -f2 -d" ") local ns=$(printf "%s 1000000000 * p" $t | dc) local b=$((m * 1024)) case $FORMAT in bench) printf "BenchmarkStaticcheck-%s-GOGC%d-wiped%d-%d 1 %.0f ns/op %.0f B/op\n" "$label" "$gc" "$wipe" "$cores" "$ns" "$b" ;; csv) printf "%s,%d,%d,%d,%.0f,%.0f\n" "$label" "$gc" "$cores" "$wipe" "$ns" "$b" ;; esac } export GO111MODULE=off if [ "$FORMAT" = "csv" ]; then printf "packages,gogc,gomaxprocs,wipe-cache,time,memory\n" fi for label in "${!PKGS[@]}"; do pkg=${PKGS[$label]} for gc in $(seq $MIN_GOGC 10 $MAX_GOGC); do for cores in $(seq $MIN_CORES $INCR_CORES $MAX_CORES); do for i in $(seq 1 $SAMPLES); do runBenchmark "$pkg" "$label" "$gc" "$cores" 1 runBenchmark "$pkg" "$label" "$gc" "$cores" 0 done done done done golang-honnef-go-tools-2024.1/_benchmarks/silent-staticcheck.sh000077500000000000000000000002051465704072200244650ustar00rootroot00000000000000#!/usr/bin/env sh /home/dominikh/prj/src/honnef.co/go/tools/cmd/staticcheck/staticcheck -checks "all" -fail "" $1 &>/dev/null exit 0 golang-honnef-go-tools-2024.1/add-check.go000066400000000000000000000055501465704072200202330ustar00rootroot00000000000000//go:build ignore package main import ( "bytes" "go/format" "log" "os" "os/exec" "path/filepath" "regexp" "strings" "text/template" ) var tmpl = ` package {{.lname}} import ( "honnef.co/go/tools/analysis/lint" "golang.org/x/tools/go/analysis" ) var SCAnalyzer = lint.InitializeAnalyzer(&lint.Analyzer{ Analyzer: &analysis.Analyzer{ Name: "{{.name}}", Run: run, Requires: []*analysis.Analyzer{}, }, Doc: &lint.RawDocumentation{ Title: "", Text: {{.emptyRaw}}, {{- if .quickfix }} Before: {{.emptyRaw}}, After: {{.emptyRaw}}, {{- end }} Since: "Unreleased", Severity: lint.SeverityWarning, }, }) var Analyzer = SCAnalyzer.Analyzer func run(pass *analysis.Pass) (any, error) { return nil, nil } ` func main() { log.SetFlags(0) var t template.Template if _, err := t.Parse(tmpl); err != nil { log.Fatalln("couldn't parse template:", err) } if len(os.Args) != 2 { log.Fatalf("Usage: %s ", os.Args[0]) } name := os.Args[1] checkRe := regexp.MustCompile(`^([A-Za-z]+)\d{4}$`) parts := checkRe.FindStringSubmatch(name) if parts == nil { log.Fatalf("invalid check name %q", name) } var catDir string prefix := strings.ToUpper(parts[1]) switch prefix { case "SA": catDir = "staticcheck" case "S": catDir = "simple" case "ST": catDir = "stylecheck" case "QF": catDir = "quickfix" default: log.Fatalf("unknown check prefix %q", prefix) } lname := strings.ToLower(name) dir := filepath.Join(catDir, lname) dst := filepath.Join(dir, lname+".go") mkdirp(dir) buf := bytes.NewBuffer(nil) vars := map[string]any{ "name": name, "lname": lname, "emptyRaw": "``", "quickfix": prefix == "QF", } if err := t.Execute(buf, vars); err != nil { log.Fatalf("couldn't generate %s: %s", dst, err) } b, err := format.Source(buf.Bytes()) if err != nil { log.Fatalf("couldn't gofmt %s: %s", dst, err) } writeFile(dst, b) testdata := filepath.Join(dir, "testdata", "src", "example.com", "pkg") mkdirp(testdata) writeFile(filepath.Join(testdata, "pkg.go"), []byte("package pkg\n")) out, err := exec.Command("go", "generate", "./...").CombinedOutput() if err != nil { log.Printf("could not run 'go generate ./...': %s", err) log.Println("Output:") log.Fatalln(string(out)) } flags := []string{ "add", "--intent-to-add", "--verbose", filepath.Join(dir, lname+"_test.go"), filepath.Join(testdata, "pkg.go"), dst, } cmd := exec.Command("git", flags...) cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr if err := cmd.Run(); err != nil { log.Fatalln("could not run 'git add':", err) } } func writeFile(path string, data []byte) { if err := os.WriteFile(path, data, 0677); err != nil { log.Fatalf("couldn't write %s: %s", path, err) } } func mkdirp(path string) { if err := os.MkdirAll(path, 0777); err != nil { log.Fatalf("couldn't create directory %s: %s", path, err) } } golang-honnef-go-tools-2024.1/analysis/000077500000000000000000000000001465704072200177175ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/callcheck/000077500000000000000000000000001465704072200216305ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/callcheck/callcheck.go000066400000000000000000000071421465704072200240740ustar00rootroot00000000000000// Package callcheck provides a framework for validating arguments in function calls. package callcheck import ( "fmt" "go/ast" "go/constant" "go/types" "golang.org/x/tools/go/analysis" "honnef.co/go/tools/analysis/report" "honnef.co/go/tools/go/ir" "honnef.co/go/tools/go/ir/irutil" "honnef.co/go/tools/go/types/typeutil" "honnef.co/go/tools/internal/passes/buildir" ) type Call struct { Pass *analysis.Pass Instr ir.CallInstruction Args []*Argument Parent *ir.Function invalids []string } func (c *Call) Invalid(msg string) { c.invalids = append(c.invalids, msg) } type Argument struct { Value Value invalids []string } type Value struct { Value ir.Value } func (arg *Argument) Invalid(msg string) { arg.invalids = append(arg.invalids, msg) } type Check func(call *Call) func Analyzer(rules map[string]Check) func(pass *analysis.Pass) (interface{}, error) { return func(pass *analysis.Pass) (interface{}, error) { return checkCalls(pass, rules) } } func checkCalls(pass *analysis.Pass, rules map[string]Check) (interface{}, error) { cb := func(caller *ir.Function, site ir.CallInstruction, callee *ir.Function) { obj, ok := callee.Object().(*types.Func) if !ok { return } r, ok := rules[typeutil.FuncName(obj)] if !ok { return } var args []*Argument irargs := site.Common().Args if callee.Signature.Recv() != nil { irargs = irargs[1:] } for _, arg := range irargs { if iarg, ok := arg.(*ir.MakeInterface); ok { arg = iarg.X } args = append(args, &Argument{Value: Value{arg}}) } call := &Call{ Pass: pass, Instr: site, Args: args, Parent: site.Parent(), } r(call) var astcall *ast.CallExpr switch source := site.Source().(type) { case *ast.CallExpr: astcall = source case *ast.DeferStmt: astcall = source.Call case *ast.GoStmt: astcall = source.Call case nil: // TODO(dh): I am not sure this can actually happen. If it // can't, we should remove this case, and also stop // checking for astcall == nil in the code that follows. default: panic(fmt.Sprintf("unhandled case %T", source)) } for idx, arg := range call.Args { for _, e := range arg.invalids { if astcall != nil { if idx < len(astcall.Args) { report.Report(pass, astcall.Args[idx], e) } else { // this is an instance of fn1(fn2()) where fn2 // returns multiple values. Report the error // at the next-best position that we have, the // first argument. An example of a check that // triggers this is checkEncodingBinaryRules. report.Report(pass, astcall.Args[0], e) } } else { report.Report(pass, site, e) } } } for _, e := range call.invalids { report.Report(pass, call.Instr, e) } } for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs { eachCall(fn, cb) } return nil, nil } func eachCall(fn *ir.Function, cb func(caller *ir.Function, site ir.CallInstruction, callee *ir.Function)) { for _, b := range fn.Blocks { for _, instr := range b.Instrs { if site, ok := instr.(ir.CallInstruction); ok { if g := site.Common().StaticCallee(); g != nil { cb(fn, site, g) } } } } } func ExtractConstExpectKind(v Value, kind constant.Kind) *ir.Const { k := extractConst(v.Value) if k == nil || k.Value == nil || k.Value.Kind() != kind { return nil } return k } func ExtractConst(v Value) *ir.Const { return extractConst(v.Value) } func extractConst(v ir.Value) *ir.Const { v = irutil.Flatten(v) switch v := v.(type) { case *ir.Const: return v case *ir.MakeInterface: return extractConst(v.X) default: return nil } } golang-honnef-go-tools-2024.1/analysis/code/000077500000000000000000000000001465704072200206315ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/code/code.go000066400000000000000000000461221465704072200220770ustar00rootroot00000000000000// Package code answers structural and type questions about Go code. package code import ( "fmt" "go/ast" "go/build/constraint" "go/constant" "go/token" "go/types" "go/version" "path/filepath" "strings" "honnef.co/go/tools/analysis/facts/generated" "honnef.co/go/tools/analysis/facts/purity" "honnef.co/go/tools/analysis/facts/tokenfile" "honnef.co/go/tools/go/ast/astutil" "honnef.co/go/tools/go/types/typeutil" "honnef.co/go/tools/knowledge" "honnef.co/go/tools/pattern" "golang.org/x/tools/go/analysis" ) type Positioner interface { Pos() token.Pos } func IsOfStringConvertibleByteSlice(pass *analysis.Pass, expr ast.Expr) bool { typ, ok := pass.TypesInfo.TypeOf(expr).Underlying().(*types.Slice) if !ok { return false } elem := types.Unalias(typ.Elem()) if version.Compare(LanguageVersion(pass, expr), "go1.18") >= 0 { // Before Go 1.18, one could not directly convert from []T (where 'type T byte') // to string. See also https://github.com/golang/go/issues/23536. elem = elem.Underlying() } return types.Identical(elem, types.Typ[types.Byte]) } func IsOfPointerToTypeWithName(pass *analysis.Pass, expr ast.Expr, name string) bool { ptr, ok := types.Unalias(pass.TypesInfo.TypeOf(expr)).(*types.Pointer) if !ok { return false } return typeutil.IsTypeWithName(ptr.Elem(), name) } func IsOfTypeWithName(pass *analysis.Pass, expr ast.Expr, name string) bool { return typeutil.IsTypeWithName(pass.TypesInfo.TypeOf(expr), name) } func IsInTest(pass *analysis.Pass, node Positioner) bool { // FIXME(dh): this doesn't work for global variables with // initializers f := pass.Fset.File(node.Pos()) return f != nil && strings.HasSuffix(f.Name(), "_test.go") } // IsMain reports whether the package being processed is a package // main. func IsMain(pass *analysis.Pass) bool { return pass.Pkg.Name() == "main" } // IsMainLike reports whether the package being processed is a // main-like package. A main-like package is a package that is // package main, or that is intended to be used by a tool framework // such as cobra to implement a command. // // Note that this function errs on the side of false positives; it may // return true for packages that aren't main-like. IsMainLike is // intended for analyses that wish to suppress diagnostics for // main-like packages to avoid false positives. func IsMainLike(pass *analysis.Pass) bool { if pass.Pkg.Name() == "main" { return true } for _, imp := range pass.Pkg.Imports() { if imp.Path() == "github.com/spf13/cobra" { return true } } return false } func SelectorName(pass *analysis.Pass, expr *ast.SelectorExpr) string { info := pass.TypesInfo sel := info.Selections[expr] if sel == nil { if x, ok := expr.X.(*ast.Ident); ok { pkg, ok := info.ObjectOf(x).(*types.PkgName) if !ok { // This shouldn't happen return fmt.Sprintf("%s.%s", x.Name, expr.Sel.Name) } return fmt.Sprintf("%s.%s", pkg.Imported().Path(), expr.Sel.Name) } panic(fmt.Sprintf("unsupported selector: %v", expr)) } if v, ok := sel.Obj().(*types.Var); ok && v.IsField() { return fmt.Sprintf("(%s).%s", typeutil.DereferenceR(sel.Recv()), sel.Obj().Name()) } else { return fmt.Sprintf("(%s).%s", sel.Recv(), sel.Obj().Name()) } } func IsNil(pass *analysis.Pass, expr ast.Expr) bool { return pass.TypesInfo.Types[expr].IsNil() } func BoolConst(pass *analysis.Pass, expr ast.Expr) bool { val := pass.TypesInfo.ObjectOf(expr.(*ast.Ident)).(*types.Const).Val() return constant.BoolVal(val) } func IsBoolConst(pass *analysis.Pass, expr ast.Expr) bool { // We explicitly don't support typed bools because more often than // not, custom bool types are used as binary enums and the explicit // comparison is desired. We err on the side of false negatives and // treat aliases like other custom types. ident, ok := expr.(*ast.Ident) if !ok { return false } obj := pass.TypesInfo.ObjectOf(ident) c, ok := obj.(*types.Const) if !ok { return false } basic, ok := c.Type().(*types.Basic) if !ok { return false } if basic.Kind() != types.UntypedBool && basic.Kind() != types.Bool { return false } return true } func ExprToInt(pass *analysis.Pass, expr ast.Expr) (int64, bool) { tv := pass.TypesInfo.Types[expr] if tv.Value == nil { return 0, false } if tv.Value.Kind() != constant.Int { return 0, false } return constant.Int64Val(tv.Value) } func ExprToString(pass *analysis.Pass, expr ast.Expr) (string, bool) { val := pass.TypesInfo.Types[expr].Value if val == nil { return "", false } if val.Kind() != constant.String { return "", false } return constant.StringVal(val), true } func CallName(pass *analysis.Pass, call *ast.CallExpr) string { // See the comment in typeutil.FuncName for why this doesn't require special handling // of aliases. fun := astutil.Unparen(call.Fun) // Instantiating a function cannot return another generic function, so doing this once is enough switch idx := fun.(type) { case *ast.IndexExpr: fun = idx.X case *ast.IndexListExpr: fun = idx.X } // (foo)[T] is not a valid instantiationg, so no need to unparen again. switch fun := fun.(type) { case *ast.SelectorExpr: fn, ok := pass.TypesInfo.ObjectOf(fun.Sel).(*types.Func) if !ok { return "" } return typeutil.FuncName(fn) case *ast.Ident: obj := pass.TypesInfo.ObjectOf(fun) switch obj := obj.(type) { case *types.Func: return typeutil.FuncName(obj) case *types.Builtin: return obj.Name() default: return "" } default: return "" } } func IsCallTo(pass *analysis.Pass, node ast.Node, name string) bool { // See the comment in typeutil.FuncName for why this doesn't require special handling // of aliases. call, ok := node.(*ast.CallExpr) if !ok { return false } return CallName(pass, call) == name } func IsCallToAny(pass *analysis.Pass, node ast.Node, names ...string) bool { // See the comment in typeutil.FuncName for why this doesn't require special handling // of aliases. call, ok := node.(*ast.CallExpr) if !ok { return false } q := CallName(pass, call) for _, name := range names { if q == name { return true } } return false } func File(pass *analysis.Pass, node Positioner) *ast.File { m := pass.ResultOf[tokenfile.Analyzer].(map[*token.File]*ast.File) return m[pass.Fset.File(node.Pos())] } // BuildConstraints returns the build constraints for file f. It considers both //go:build lines as well as // GOOS and GOARCH in file names. func BuildConstraints(pass *analysis.Pass, f *ast.File) (constraint.Expr, bool) { var expr constraint.Expr for _, cmt := range f.Comments { if len(cmt.List) == 0 { continue } for _, el := range cmt.List { if el.Pos() > f.Package { break } if line := el.Text; strings.HasPrefix(line, "//go:build") { var err error expr, err = constraint.Parse(line) if err != nil { expr = nil } break } } } name := pass.Fset.PositionFor(f.Pos(), false).Filename oexpr := constraintsFromName(name) if oexpr != nil { if expr == nil { expr = oexpr } else { expr = &constraint.AndExpr{X: expr, Y: oexpr} } } return expr, expr != nil } func constraintsFromName(name string) constraint.Expr { name = filepath.Base(name) name = strings.TrimSuffix(name, ".go") name = strings.TrimSuffix(name, "_test") var goos, goarch string switch strings.Count(name, "_") { case 0: // No GOOS or GOARCH in the file name. case 1: _, c, _ := strings.Cut(name, "_") if _, ok := knowledge.KnownGOOS[c]; ok { goos = c } else if _, ok := knowledge.KnownGOARCH[c]; ok { goarch = c } default: n := strings.LastIndex(name, "_") if _, ok := knowledge.KnownGOOS[name[n+1:]]; ok { // The file name is *_stuff_GOOS.go goos = name[n+1:] } else if _, ok := knowledge.KnownGOARCH[name[n+1:]]; ok { // The file name is *_GOOS_GOARCH.go or *_stuff_GOARCH.go goarch = name[n+1:] _, c, _ := strings.Cut(name[:n], "_") if _, ok := knowledge.KnownGOOS[c]; ok { // The file name is *_GOOS_GOARCH.go goos = c } } else { // The file name could also be something like foo_windows_nonsense.go — and because nonsense // isn't a known GOARCH, "windows" won't be interpreted as a GOOS, either. } } var expr constraint.Expr if goos != "" { expr = &constraint.TagExpr{Tag: goos} } if goarch != "" { if expr == nil { expr = &constraint.TagExpr{Tag: goarch} } else { expr = &constraint.AndExpr{X: expr, Y: &constraint.TagExpr{Tag: goarch}} } } return expr } // IsGenerated reports whether pos is in a generated file. It ignores // //line directives. func IsGenerated(pass *analysis.Pass, pos token.Pos) bool { _, ok := Generator(pass, pos) return ok } // Generator returns the generator that generated the file containing // pos. It ignores //line directives. func Generator(pass *analysis.Pass, pos token.Pos) (generated.Generator, bool) { file := pass.Fset.PositionFor(pos, false).Filename m := pass.ResultOf[generated.Analyzer].(map[string]generated.Generator) g, ok := m[file] return g, ok } // MayHaveSideEffects reports whether expr may have side effects. If // the purity argument is nil, this function implements a purely // syntactic check, meaning that any function call may have side // effects, regardless of the called function's body. Otherwise, // purity will be consulted to determine the purity of function calls. func MayHaveSideEffects(pass *analysis.Pass, expr ast.Expr, purity purity.Result) bool { switch expr := expr.(type) { case *ast.BadExpr: return true case *ast.Ellipsis: return MayHaveSideEffects(pass, expr.Elt, purity) case *ast.FuncLit: // the literal itself cannot have side effects, only calling it // might, which is handled by CallExpr. return false case *ast.ArrayType, *ast.StructType, *ast.FuncType, *ast.InterfaceType, *ast.MapType, *ast.ChanType: // types cannot have side effects return false case *ast.BasicLit: return false case *ast.BinaryExpr: return MayHaveSideEffects(pass, expr.X, purity) || MayHaveSideEffects(pass, expr.Y, purity) case *ast.CallExpr: if purity == nil { return true } switch obj := typeutil.Callee(pass.TypesInfo, expr).(type) { case *types.Func: if _, ok := purity[obj]; !ok { return true } case *types.Builtin: switch obj.Name() { case "len", "cap": default: return true } default: return true } for _, arg := range expr.Args { if MayHaveSideEffects(pass, arg, purity) { return true } } return false case *ast.CompositeLit: if MayHaveSideEffects(pass, expr.Type, purity) { return true } for _, elt := range expr.Elts { if MayHaveSideEffects(pass, elt, purity) { return true } } return false case *ast.Ident: return false case *ast.IndexExpr: return MayHaveSideEffects(pass, expr.X, purity) || MayHaveSideEffects(pass, expr.Index, purity) case *ast.IndexListExpr: // In theory, none of the checks are necessary, as IndexListExpr only involves types. But there is no harm in // being safe. if MayHaveSideEffects(pass, expr.X, purity) { return true } for _, idx := range expr.Indices { if MayHaveSideEffects(pass, idx, purity) { return true } } return false case *ast.KeyValueExpr: return MayHaveSideEffects(pass, expr.Key, purity) || MayHaveSideEffects(pass, expr.Value, purity) case *ast.SelectorExpr: return MayHaveSideEffects(pass, expr.X, purity) case *ast.SliceExpr: return MayHaveSideEffects(pass, expr.X, purity) || MayHaveSideEffects(pass, expr.Low, purity) || MayHaveSideEffects(pass, expr.High, purity) || MayHaveSideEffects(pass, expr.Max, purity) case *ast.StarExpr: return MayHaveSideEffects(pass, expr.X, purity) case *ast.TypeAssertExpr: return MayHaveSideEffects(pass, expr.X, purity) case *ast.UnaryExpr: if MayHaveSideEffects(pass, expr.X, purity) { return true } return expr.Op == token.ARROW || expr.Op == token.AND case *ast.ParenExpr: return MayHaveSideEffects(pass, expr.X, purity) case nil: return false default: panic(fmt.Sprintf("internal error: unhandled type %T", expr)) } } // LanguageVersion returns the version of the Go language that node has access to. This // might differ from the version of the Go standard library. func LanguageVersion(pass *analysis.Pass, node Positioner) string { // As of Go 1.21, two places can specify the minimum Go version: // - 'go' directives in go.mod and go.work files // - individual files by using '//go:build' // // Individual files can upgrade to a higher version than the module version. Individual files // can also downgrade to a lower version, but only if the module version is at least Go 1.21. // // The restriction on downgrading doesn't matter to us. All language changes before Go 1.22 will // not type-check on versions that are too old, and thus never reach our analyzes. In practice, // such ineffective downgrading will always be useless, as the compiler will not restrict the // language features used, and doesn't ever rely on minimum versions to restrict the use of the // standard library. However, for us, both choices (respecting or ignoring ineffective // downgrading) have equal complexity, but only respecting it has a non-zero chance of reducing // noisy positives. // // The minimum Go versions are exposed via go/ast.File.GoVersion and go/types.Package.GoVersion. // ast.File's version is populated by the parser, whereas types.Package's version is populated // from the Go version specified in the types.Config, which is set by our package loader, based // on the module information provided by go/packages, via 'go list -json'. // // As of Go 1.21, standard library packages do not present themselves as modules, and thus do // not have a version set on their types.Package. In this case, we fall back to the version // provided by our '-go' flag. In most cases, '-go' defaults to 'module', which falls back to // the Go version that Staticcheck was built with when no module information exists. In the // future, the standard library will hopefully be a proper module (see // https://github.com/golang/go/issues/61174#issuecomment-1622471317). In that case, the version // of standard library packages will match that of the used Go version. At that point, // Staticcheck will refuse to work with Go versions that are too new, to avoid misinterpreting // code due to language changes. // // We also lack module information when building in GOPATH mode. In this case, the implied // language version is at most Go 1.21, as per https://github.com/golang/go/issues/60915. We // don't handle this yet, and it will not matter until Go 1.22. // // It is not clear how per-file downgrading behaves in GOPATH mode. On the one hand, no module // version at all is provided, which should preclude per-file downgrading. On the other hand, // https://github.com/golang/go/issues/60915 suggests that the language version is at most 1.21 // in GOPATH mode, which would allow per-file downgrading. Again it doesn't affect us, as all // relevant language changes before Go 1.22 will lead to type-checking failures and never reach // us. // // Per-file upgrading is permitted in GOPATH mode. // If the file has its own Go version, we will return that. Otherwise, we default to // the type checker's GoVersion, which is populated from either the Go module, or from // our '-go' flag. return pass.TypesInfo.FileVersions[File(pass, node)] } // StdlibVersion returns the version of the Go standard library that node can expect to // have access to. This might differ from the language version for versions of Go older // than 1.21. func StdlibVersion(pass *analysis.Pass, node Positioner) string { // The Go version as specified in go.mod or via the '-go' flag n := pass.Pkg.GoVersion() f := File(pass, node) if f == nil { panic(fmt.Sprintf("no file found for node with position %s", pass.Fset.PositionFor(node.Pos(), false))) } if nf := f.GoVersion; nf != "" { if version.Compare(n, "go1.21") == -1 { // Before Go 1.21, the Go version set in go.mod specified the maximum language // version available to the module. It wasn't uncommon to set the version to // Go 1.20 but restrict usage of 1.20 functionality (both language and stdlib) // to files tagged for 1.20, and supporting a lower version overall. As such, // a file tagged lower than the module version couldn't expect to have access // to the standard library of the version set in go.mod. // // At the same time, a file tagged higher than the module version, while not // able to use newer language features, would still have been able to use a // newer standard library. // // While Go 1.21's behavior has been backported to 1.19.11 and 1.20.6, users' // expectations have not. return nf } else { // Go 1.21 and newer refuse to build modules that depend on versions newer // than the used version of the Go toolchain. This means that in a 1.22 module // with a file tagged as 1.17, the file can expect to have access to 1.22's // standard library (but not to 1.22 language features). A file tagged with a // version higher than the minimum version has access to the newer standard // library (and language features.) // // Do note that strictly speaking we're conflating the Go version and the // module version in our check. Nothing is stopping a user from using Go 1.17 // (which didn't implement the new rules for versions in go.mod) to build a Go // 1.22 module, in which case a file tagged with go1.17 will not have acces to the 1.22 // standard library. However, we believe that if a module requires 1.21 or // newer, then the author clearly expects the new behavior, and doesn't care // for the old one. Otherwise they would've specified an older version. // // In other words, the module version also specifies what it itself actually means, with // >=1.21 being a minimum version for the toolchain, and <1.21 being a maximum version for // the language. if version.Compare(nf, n) == 1 { return nf } } } return n } var integerLiteralQ = pattern.MustParse(`(IntegerLiteral tv)`) func IntegerLiteral(pass *analysis.Pass, node ast.Node) (types.TypeAndValue, bool) { m, ok := Match(pass, integerLiteralQ, node) if !ok { return types.TypeAndValue{}, false } return m.State["tv"].(types.TypeAndValue), true } func IsIntegerLiteral(pass *analysis.Pass, node ast.Node, value constant.Value) bool { tv, ok := IntegerLiteral(pass, node) if !ok { return false } return constant.Compare(tv.Value, token.EQL, value) } // IsMethod reports whether expr is a method call of a named method with signature meth. // If name is empty, it is not checked. // For now, method expressions (Type.Method(recv, ..)) are not considered method calls. func IsMethod(pass *analysis.Pass, expr *ast.SelectorExpr, name string, meth *types.Signature) bool { if name != "" && expr.Sel.Name != name { return false } sel, ok := pass.TypesInfo.Selections[expr] if !ok || sel.Kind() != types.MethodVal { return false } return types.Identical(sel.Type(), meth) } func RefersTo(pass *analysis.Pass, expr ast.Expr, ident types.Object) bool { found := false fn := func(node ast.Node) bool { ident2, ok := node.(*ast.Ident) if !ok { return true } if ident == pass.TypesInfo.ObjectOf(ident2) { found = true return false } return true } ast.Inspect(expr, fn) return found } golang-honnef-go-tools-2024.1/analysis/code/code_test.go000066400000000000000000000020061465704072200231270ustar00rootroot00000000000000package code import "testing" var constraintsFromNameTests = []struct { in string out string }{ {"foo.go", ""}, {"foo_windows.go", "windows"}, {"foo_unix.go", ""}, {"foo_windows_amd64.go", "windows && amd64"}, {"foo_amd64.go", "amd64"}, {"foo_windows_nonsense.go", ""}, {"foo_nonsense_amd64.go", "amd64"}, {"foo_nonsense_windows.go", "windows"}, {"foo_nonsense_windows_amd64.go", "amd64"}, {"foo_windows_test.go", "windows"}, {"linux.go", ""}, {"linux_amd64.go", "amd64"}, {"amd64_linux.go", "linux"}, {"amd64.go", ""}, } func TestConstraintsFromName(t *testing.T) { for _, tc := range constraintsFromNameTests { expr := constraintsFromName(tc.in) var out string if expr != nil { out = expr.String() } if out != tc.out { t.Errorf("constraintsFromName(%q) == %q, expected %q", tc.in, out, tc.out) } } } func FuzzConstraintsFromName(f *testing.F) { for _, tc := range constraintsFromNameTests { f.Add(tc.in) } f.Fuzz(func(t *testing.T, name string) { constraintsFromName(name) }) } golang-honnef-go-tools-2024.1/analysis/code/visit.go000066400000000000000000000025771465704072200223310ustar00rootroot00000000000000package code import ( "bytes" "go/ast" "go/format" "honnef.co/go/tools/pattern" "golang.org/x/tools/go/analysis" "golang.org/x/tools/go/analysis/passes/inspect" "golang.org/x/tools/go/ast/inspector" ) func Preorder(pass *analysis.Pass, fn func(ast.Node), types ...ast.Node) { pass.ResultOf[inspect.Analyzer].(*inspector.Inspector).Preorder(types, fn) } func PreorderStack(pass *analysis.Pass, fn func(ast.Node, []ast.Node), types ...ast.Node) { pass.ResultOf[inspect.Analyzer].(*inspector.Inspector).WithStack(types, func(n ast.Node, push bool, stack []ast.Node) (proceed bool) { if push { fn(n, stack) } return true }) } func Match(pass *analysis.Pass, q pattern.Pattern, node ast.Node) (*pattern.Matcher, bool) { // Note that we ignore q.Relevant – callers of Match usually use // AST inspectors that already filter on nodes we're interested // in. m := &pattern.Matcher{TypesInfo: pass.TypesInfo} ok := m.Match(q, node) return m, ok } func MatchAndEdit(pass *analysis.Pass, before, after pattern.Pattern, node ast.Node) (*pattern.Matcher, []analysis.TextEdit, bool) { m, ok := Match(pass, before, node) if !ok { return m, nil, false } r := pattern.NodeToAST(after.Root, m.State) buf := &bytes.Buffer{} format.Node(buf, pass.Fset, r) edit := []analysis.TextEdit{{ Pos: node.Pos(), End: node.End(), NewText: buf.Bytes(), }} return m, edit, true } golang-honnef-go-tools-2024.1/analysis/dfa/000077500000000000000000000000001465704072200204515ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/dfa/dfa.el000066400000000000000000000017631465704072200215340ustar00rootroot00000000000000(require 'cl-lib) (defun format-state (prefix state ⊤ ⊥) (cond ((string= state "⊥") ⊥) ((string= state "⊤") ⊤) (t (format "%s%s" prefix state)))) (defun dh/orgtbl-to-dfa-binary-table (table params) (let* ((table (--filter (not (equal 'hline it)) table)) (rows (1- (length table))) (cols (1- (length (nth 0 table)))) (prefix (plist-get params :prefix)) (var (plist-get params :var)) (⊤ (plist-get params :⊤)) (⊥ (plist-get params :⊥))) (concat (if var (concat "var " var " = ") "") (format "dfa.BinaryTable(%s, map[[2]%s]%s{\n" ⊤ prefix prefix) (mapconcat (lambda (rowIdx) (mapconcat (lambda (colIdx) (let* ((x (nth 0 (nth rowIdx table))) (y (nth colIdx (nth 0 table))) (z (nth colIdx (nth rowIdx table)))) (format "{%s, %s}: %s," (format-state prefix x ⊤ ⊥) (format-state prefix y ⊤ ⊥) (format-state prefix z ⊤ ⊥)))) (number-sequence 1 cols) "\n")) (number-sequence 1 rows) "\n\n") "\n})"))) golang-honnef-go-tools-2024.1/analysis/dfa/dfa.go000066400000000000000000000246541465704072200215450ustar00rootroot00000000000000// Package dfa provides types and functions for implementing data-flow analyses. package dfa import ( "cmp" "fmt" "log" "math/bits" "slices" "strings" "sync" "golang.org/x/exp/constraints" "honnef.co/go/tools/go/ir" ) const debugging = false func debugf(f string, args ...any) { if debugging { log.Printf(f, args...) } } // Join defines the [∨] operation for a [join-semilattice]. It must implement a commutative and associative binary operation // that returns the least upper bound of two states from S. // // Code that calls Join functions is expected to handle the [⊥ and ⊤ elements], as well as implement idempotency. That is, // the following properties will be enforced: // // - x ∨ ⊥ = x // - x ∨ ⊤ = ⊤ // - x ∨ x = x // // Simple table-based join functions can be created using [JoinTable]. // // [∨]: https://en.wikipedia.org/wiki/Join_and_meet // [join-semilattice]: https://en.wikipedia.org/wiki/Semilattice // [⊥ and ⊤ elements]: https://en.wikipedia.org/wiki/Greatest_element_and_least_element#Top_and_bottom type Join[S comparable] func(S, S) S // Mapping maps a single [ir.Value] to an abstract state. type Mapping[S comparable] struct { Value ir.Value State S Decision Decision } // Decision describes how a mapping from an [ir.Value] to an abstract state came to be. // Decisions are provided by transfer functions when they create mappings. type Decision struct { // The relevant values that the transfer function used to make the decision. Inputs []ir.Value // A human-readable description of the decision. Description string // Whether this is the source of an abstract state. For example, in a taint analysis, the call to a function that // produces a tainted value would be the source of the taint state, and any instructions that operate on // and propagate tainted values would not be sources. Source bool } func (m Mapping[S]) String() string { return fmt.Sprintf("%s = %v", m.Value.Name(), m.State) } // M is a helper for constructing instances of [Mapping]. func M[S comparable](v ir.Value, s S, d Decision) Mapping[S] { return Mapping[S]{Value: v, State: s, Decision: d} } // Ms is a helper for constructing slices of mappings. // // Example: // // Ms(M(v1, d1, ...), M(v2, d2, ...)) func Ms[S comparable](ms ...Mapping[S]) []Mapping[S] { return ms } // Framework describes a monotone data-flow framework ⟨S, ∨, Transfer⟩ using a bounded join-semilattice ⟨S, ∨⟩ and a // monotonic transfer function. // // Transfer implements the transfer function. Given an instruction, it should return zero or more mappings from IR // values to abstract values, i.e. values from the semilattice. Transfer must be monotonic. ϕ instructions are handled // automatically and do not cause Transfer to be called. // // The set S is defined implicitly by the values returned by Join and Transfer and needn't be finite. In addition, it // contains the elements ⊥ and ⊤ (Bottom and Top) with Join(x, ⊥) = x and Join(x, ⊤) = ⊤. The provided Join function is // wrapped to handle these elements automatically. All IR values start in the ⊥ state. // // Abstract states are associated with IR values. As such, the analysis is sparse and favours the partitioned variable // lattice (PVL) property. type Framework[S comparable] struct { Join Join[S] Transfer func(*Instance[S], ir.Instruction) []Mapping[S] Bottom S Top S } // Start returns a new instance of the framework. See also [Framework.Forward]. func (fw *Framework[S]) Start() *Instance[S] { if fw.Bottom == fw.Top { panic("framework's ⊥ and ⊤ are identical; did you forget to specify them?") } return &Instance[S]{ Framework: fw, Mapping: map[ir.Value]Mapping[S]{}, } } // Forward runs an intraprocedural forward data flow analysis, using an iterative fixed-point algorithm, given the // functions specified in the framework. It combines [Framework.Start] and [Instance.Forward]. func (fw *Framework[S]) Forward(fn *ir.Function) *Instance[S] { ins := fw.Start() ins.Forward(fn) return ins } // Dot returns a directed graph in [Graphviz] format that represents the finite join-semilattice ⟨S, ≤⟩. // Vertices represent elements in S and edges represent the ≤ relation between elements. // We map from ⟨S, ∨⟩ to ⟨S, ≤⟩ by computing x ∨ y for all elements in [S]², where x ≤ y iff x ∨ y == y. // // The resulting graph can be filtered through [tred] to compute the transitive reduction of the graph, the // visualisation of which corresponds to the Hasse diagram of the semilattice. // // The set of states should not include the ⊥ and ⊤ elements. // // [Graphviz]: https://graphviz.org/ // [tred]: https://graphviz.org/docs/cli/tred/ func Dot[S comparable](fn Join[S], states []S, bottom, top S) string { var sb strings.Builder sb.WriteString("digraph{\n") sb.WriteString("rankdir=\"BT\"\n") for i, v := range states { if vs, ok := any(v).(fmt.Stringer); ok { fmt.Fprintf(&sb, "n%d [label=%q]\n", i, vs) } else { fmt.Fprintf(&sb, "n%d [label=%q]\n", i, fmt.Sprintf("%v", v)) } } for dx, x := range states { for dy, y := range states { if dx == dy { continue } if join(fn, x, y, bottom, top) == y { fmt.Fprintf(&sb, "n%d -> n%d\n", dx, dy) } } } sb.WriteString("}") return sb.String() } // Instance is an instance of a data-flow analysis. It is created by [Framework.Forward]. type Instance[S comparable] struct { Framework *Framework[S] // Mapping is the result of the analysis. Consider using Instance.Value instead of accessing Mapping // directly, as it correctly returns ⊥ for missing values. Mapping map[ir.Value]Mapping[S] } // Set maps v to the abstract value d. It does not apply any checks. This should only be used before calling [Instance.Forward], to set // initial states of values. func (ins *Instance[S]) Set(v ir.Value, d S) { ins.Mapping[v] = Mapping[S]{Value: v, State: d} } // Value returns the abstract value for v. If none was set, it returns ⊥. func (ins *Instance[S]) Value(v ir.Value) S { m, ok := ins.Mapping[v] if ok { return m.State } else { return ins.Framework.Bottom } } // Decision returns the decision of the mapping for v, if any. func (ins *Instance[S]) Decision(v ir.Value) Decision { return ins.Mapping[v].Decision } var dfsDebugMu sync.Mutex func join[S comparable](fn Join[S], a, b, bottom, top S) S { switch { case a == top || b == top: return top case a == bottom: return b case b == bottom: return a case a == b: return a default: return fn(a, b) } } // Forward runs a forward data-flow analysis on fn. func (ins *Instance[S]) Forward(fn *ir.Function) { if debugging { dfsDebugMu.Lock() defer dfsDebugMu.Unlock() } debugf("Analyzing %s\n", fn) if ins.Mapping == nil { ins.Mapping = map[ir.Value]Mapping[S]{} } worklist := map[ir.Instruction]struct{}{} for _, b := range fn.Blocks { for _, instr := range b.Instrs { worklist[instr] = struct{}{} } } for len(worklist) > 0 { var instr ir.Instruction for instr = range worklist { break } delete(worklist, instr) var ds []Mapping[S] if phi, ok := instr.(*ir.Phi); ok { d := ins.Framework.Bottom for _, edge := range phi.Edges { a, b := d, ins.Value(edge) d = join(ins.Framework.Join, a, b, ins.Framework.Bottom, ins.Framework.Top) debugf("join(%v, %v) = %v", a, b, d) } ds = []Mapping[S]{{Value: phi, State: d, Decision: Decision{Inputs: phi.Edges, Description: "this variable merges the results of multiple branches"}}} } else { ds = ins.Framework.Transfer(ins, instr) } if len(ds) > 0 { if v, ok := instr.(ir.Value); ok { debugf("transfer(%s = %s) = %v", v.Name(), instr, ds) } else { debugf("transfer(%s) = %v", instr, ds) } } for i, d := range ds { old := ins.Value(d.Value) dd := d.State if dd != old { if j := join(ins.Framework.Join, old, dd, ins.Framework.Bottom, ins.Framework.Top); j != dd { panic(fmt.Sprintf("transfer function isn't monotonic; Transfer(%v)[%d] = %v; join(%v, %v) = %v", instr, i, dd, old, dd, j)) } ins.Mapping[d.Value] = Mapping[S]{Value: d.Value, State: dd, Decision: d.Decision} for _, ref := range *instr.Referrers() { worklist[ref] = struct{}{} } } } printMapping(fn, ins.Mapping) } } // Propagate is a helper for creating a [Mapping] that propagates the abstract state of src to dst. // The desc parameter is used as the value of Decision.Description. func (ins *Instance[S]) Propagate(dst, src ir.Value, desc string) Mapping[S] { return M(dst, ins.Value(src), Decision{Inputs: []ir.Value{src}, Description: desc}) } func (ins *Instance[S]) Transform(dst ir.Value, s S, src ir.Value, desc string) Mapping[S] { return M(dst, s, Decision{Inputs: []ir.Value{src}, Description: desc}) } func printMapping[S any](fn *ir.Function, m map[ir.Value]S) { if !debugging { return } debugf("Mapping for %s:\n", fn) var keys []ir.Value for k := range m { keys = append(keys, k) } slices.SortFunc(keys, func(a, b ir.Value) int { return cmp.Compare(a.ID(), b.ID()) }) for _, k := range keys { v := m[k] debugf("\t%v\n", v) } } // BinaryTable returns a binary operator based on the provided mapping. // For missing pairs of values, the default value will be returned. func BinaryTable[S comparable](default_ S, m map[[2]S]S) func(S, S) S { return func(a, b S) S { if d, ok := m[[2]S{a, b}]; ok { return d } else if d, ok := m[[2]S{b, a}]; ok { return d } else { return default_ } } } // JoinTable returns a [Join] function based on the provided mapping. // For missing pairs of values, the default value will be returned. func JoinTable[S comparable](top S, m map[[2]S]S) Join[S] { return func(a, b S) S { if d, ok := m[[2]S{a, b}]; ok { return d } else if d, ok := m[[2]S{b, a}]; ok { return d } else { return top } } } func PowerSet[S constraints.Integer](all S) []S { out := make([]S, all+1) for i := range out { out[i] = S(i) } return out } func MapSet[S constraints.Integer](set S, fn func(S) S) S { bits := 64 - bits.LeadingZeros64(uint64(set)) var out S for i := 0; i < bits; i++ { if b := (set & (1 << i)); b != 0 { out |= fn(b) } } return out } func MapCartesianProduct[S constraints.Integer](x, y S, fn func(S, S) S) S { bitsX := 64 - bits.LeadingZeros64(uint64(x)) bitsY := 64 - bits.LeadingZeros64(uint64(y)) var out S for i := 0; i < bitsX; i++ { for j := 0; j < bitsY; j++ { bx := x & (1 << i) by := y & (1 << j) if bx != 0 && by != 0 { out |= fn(bx, by) } } } return out } golang-honnef-go-tools-2024.1/analysis/edit/000077500000000000000000000000001465704072200206445ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/edit/edit.go000066400000000000000000000037721465704072200221310ustar00rootroot00000000000000// Package edit contains helpers for creating suggested fixes. package edit import ( "bytes" "go/ast" "go/format" "go/token" "golang.org/x/tools/go/analysis" "honnef.co/go/tools/pattern" ) // Ranger describes values that have a start and end position. // In most cases these are either ast.Node or manually constructed ranges. type Ranger interface { Pos() token.Pos End() token.Pos } // Range implements the Ranger interface. type Range [2]token.Pos func (r Range) Pos() token.Pos { return r[0] } func (r Range) End() token.Pos { return r[1] } // ReplaceWithString replaces a range with a string. func ReplaceWithString(old Ranger, new string) analysis.TextEdit { return analysis.TextEdit{ Pos: old.Pos(), End: old.End(), NewText: []byte(new), } } // ReplaceWithNode replaces a range with an AST node. func ReplaceWithNode(fset *token.FileSet, old Ranger, new ast.Node) analysis.TextEdit { buf := &bytes.Buffer{} if err := format.Node(buf, fset, new); err != nil { panic("internal error: " + err.Error()) } return analysis.TextEdit{ Pos: old.Pos(), End: old.End(), NewText: buf.Bytes(), } } // ReplaceWithPattern replaces a range with the result of executing a pattern. func ReplaceWithPattern(fset *token.FileSet, old Ranger, new pattern.Pattern, state pattern.State) analysis.TextEdit { r := pattern.NodeToAST(new.Root, state) buf := &bytes.Buffer{} format.Node(buf, fset, r) return analysis.TextEdit{ Pos: old.Pos(), End: old.End(), NewText: buf.Bytes(), } } // Delete deletes a range of code. func Delete(old Ranger) analysis.TextEdit { return analysis.TextEdit{ Pos: old.Pos(), End: old.End(), NewText: nil, } } func Fix(msg string, edits ...analysis.TextEdit) analysis.SuggestedFix { return analysis.SuggestedFix{ Message: msg, TextEdits: edits, } } // Selector creates a new selector expression. func Selector(x, sel string) *ast.SelectorExpr { return &ast.SelectorExpr{ X: &ast.Ident{Name: x}, Sel: &ast.Ident{Name: sel}, } } golang-honnef-go-tools-2024.1/analysis/facts/000077500000000000000000000000001465704072200210175ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/deprecated/000077500000000000000000000000001465704072200231175ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/deprecated/deprecated.go000066400000000000000000000067741465704072200255640ustar00rootroot00000000000000package deprecated import ( "go/ast" "go/token" "go/types" "reflect" "strings" "golang.org/x/tools/go/analysis" ) type IsDeprecated struct{ Msg string } func (*IsDeprecated) AFact() {} func (d *IsDeprecated) String() string { return "Deprecated: " + d.Msg } type Result struct { Objects map[types.Object]*IsDeprecated Packages map[*types.Package]*IsDeprecated } var Analyzer = &analysis.Analyzer{ Name: "fact_deprecated", Doc: "Mark deprecated objects", Run: deprecated, FactTypes: []analysis.Fact{(*IsDeprecated)(nil)}, ResultType: reflect.TypeOf(Result{}), } func deprecated(pass *analysis.Pass) (interface{}, error) { var names []*ast.Ident extractDeprecatedMessage := func(docs []*ast.CommentGroup) string { for _, doc := range docs { if doc == nil { continue } parts := strings.Split(doc.Text(), "\n\n") for _, part := range parts { if !strings.HasPrefix(part, "Deprecated: ") { continue } alt := part[len("Deprecated: "):] alt = strings.Replace(alt, "\n", " ", -1) return alt } } return "" } doDocs := func(names []*ast.Ident, docs []*ast.CommentGroup) { alt := extractDeprecatedMessage(docs) if alt == "" { return } for _, name := range names { obj := pass.TypesInfo.ObjectOf(name) pass.ExportObjectFact(obj, &IsDeprecated{alt}) } } var docs []*ast.CommentGroup for _, f := range pass.Files { docs = append(docs, f.Doc) } if alt := extractDeprecatedMessage(docs); alt != "" { // Don't mark package syscall as deprecated, even though // it is. A lot of people still use it for simple // constants like SIGKILL, and I am not comfortable // telling them to use x/sys for that. if pass.Pkg.Path() != "syscall" { pass.ExportPackageFact(&IsDeprecated{alt}) } } docs = docs[:0] for _, f := range pass.Files { fn := func(node ast.Node) bool { if node == nil { return true } var ret bool switch node := node.(type) { case *ast.GenDecl: switch node.Tok { case token.TYPE, token.CONST, token.VAR: docs = append(docs, node.Doc) for i := range node.Specs { switch n := node.Specs[i].(type) { case *ast.ValueSpec: names = append(names, n.Names...) case *ast.TypeSpec: names = append(names, n.Name) } } ret = true default: return false } case *ast.FuncDecl: docs = append(docs, node.Doc) names = []*ast.Ident{node.Name} ret = false case *ast.TypeSpec: docs = append(docs, node.Doc) names = []*ast.Ident{node.Name} ret = true case *ast.ValueSpec: docs = append(docs, node.Doc) names = node.Names ret = false case *ast.File: return true case *ast.StructType: for _, field := range node.Fields.List { doDocs(field.Names, []*ast.CommentGroup{field.Doc}) } return false case *ast.InterfaceType: for _, field := range node.Methods.List { doDocs(field.Names, []*ast.CommentGroup{field.Doc}) } return false default: return false } if len(names) == 0 || len(docs) == 0 { return ret } doDocs(names, docs) docs = docs[:0] names = nil return ret } ast.Inspect(f, fn) } out := Result{ Objects: map[types.Object]*IsDeprecated{}, Packages: map[*types.Package]*IsDeprecated{}, } for _, fact := range pass.AllObjectFacts() { out.Objects[fact.Object] = fact.Fact.(*IsDeprecated) } for _, fact := range pass.AllPackageFacts() { out.Packages[fact.Package] = fact.Fact.(*IsDeprecated) } return out, nil } golang-honnef-go-tools-2024.1/analysis/facts/deprecated/deprecated_test.go000066400000000000000000000003231465704072200266030ustar00rootroot00000000000000package deprecated import ( "testing" "golang.org/x/tools/go/analysis/analysistest" ) func TestDeprecated(t *testing.T) { analysistest.Run(t, analysistest.TestData(), Analyzer, "example.com/Deprecated") } golang-honnef-go-tools-2024.1/analysis/facts/deprecated/testdata/000077500000000000000000000000001465704072200247305ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/deprecated/testdata/src/000077500000000000000000000000001465704072200255175ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/deprecated/testdata/src/example.com/000077500000000000000000000000001465704072200277275ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/deprecated/testdata/src/example.com/Deprecated/000077500000000000000000000000001465704072200317675ustar00rootroot00000000000000Deprecated.go000066400000000000000000000023171465704072200343020ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/deprecated/testdata/src/example.com/Deprecatedpackage pkg // Deprecated: Don't use this. func fn2() { // want fn2:`Deprecated: Don't use this\.` } // This is a function. // // Deprecated: Don't use this. // // Here is how you might use it instead. func fn3() { // want fn3:`Deprecated: Don't use this\.` } // Handle cases like: // // Taken from "os" package: // // ``` // // Deprecated: Use io.SeekStart, io.SeekCurrent, and io.SeekEnd. // const ( // SEEK_SET int = 0 // seek relative to the origin of the file // SEEK_CUR int = 1 // seek relative to the current offset // SEEK_END int = 2 // seek relative to the end // ) // ``` // // Here all three consts i.e., os.SEEK_SET, os.SEEK_CUR and os.SEEK_END are // deprecated and not just os.SEEK_SET. // Deprecated: Don't use this. var ( SEEK_A = 0 // want SEEK_A:`Deprecated: Don't use this\.` SEEK_B = 1 // want SEEK_B:`Deprecated: Don't use this\.` SEEK_C = 2 // want SEEK_C:`Deprecated: Don't use this\.` ) // Deprecated: Don't use this. type ( pair struct{ x, y int } // want pair:`Deprecated: Don't use this\.` cube struct{ x, y, z int } // want cube:`Deprecated: Don't use this\.` ) // Deprecated: Don't use this. var SEEK_D = 3 // want SEEK_D:`Deprecated: Don't use this\.` var SEEK_E = 4 var SEEK_F = 5 golang-honnef-go-tools-2024.1/analysis/facts/directives/000077500000000000000000000000001465704072200231605ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/directives/directives.go000066400000000000000000000007201465704072200256470ustar00rootroot00000000000000package directives import ( "reflect" "golang.org/x/tools/go/analysis" "honnef.co/go/tools/analysis/lint" ) func directives(pass *analysis.Pass) (interface{}, error) { return lint.ParseDirectives(pass.Files, pass.Fset), nil } var Analyzer = &analysis.Analyzer{ Name: "directives", Doc: "extracts linter directives", Run: directives, RunDespiteErrors: true, ResultType: reflect.TypeOf([]lint.Directive{}), } golang-honnef-go-tools-2024.1/analysis/facts/generated/000077500000000000000000000000001465704072200227555ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/generated/generated.go000066400000000000000000000035571465704072200252540ustar00rootroot00000000000000package generated import ( "bufio" "bytes" "io" "os" "reflect" "strings" "golang.org/x/tools/go/analysis" ) type Generator int // A list of known generators we can detect const ( Unknown Generator = iota Goyacc Cgo Stringer ProtocGenGo ) var ( // used by cgo before Go 1.11 oldCgo = []byte("// Created by cgo - DO NOT EDIT") prefix = []byte("// Code generated ") suffix = []byte(" DO NOT EDIT.") nl = []byte("\n") crnl = []byte("\r\n") ) func isGenerated(path string) (Generator, bool) { f, err := os.Open(path) if err != nil { return 0, false } defer f.Close() br := bufio.NewReader(f) for { s, err := br.ReadBytes('\n') if err != nil && err != io.EOF { return 0, false } s = bytes.TrimSuffix(s, crnl) s = bytes.TrimSuffix(s, nl) if bytes.HasPrefix(s, prefix) && bytes.HasSuffix(s, suffix) { if len(s)-len(suffix) < len(prefix) { return Unknown, true } text := string(s[len(prefix) : len(s)-len(suffix)]) switch text { case "by goyacc.": return Goyacc, true case "by cmd/cgo;": return Cgo, true case "by protoc-gen-go.": return ProtocGenGo, true } if strings.HasPrefix(text, `by "stringer `) { return Stringer, true } if strings.HasPrefix(text, `by goyacc `) { return Goyacc, true } return Unknown, true } if bytes.Equal(s, oldCgo) { return Cgo, true } if err == io.EOF { break } } return 0, false } var Analyzer = &analysis.Analyzer{ Name: "isgenerated", Doc: "annotate file names that have been code generated", Run: func(pass *analysis.Pass) (interface{}, error) { m := map[string]Generator{} for _, f := range pass.Files { path := pass.Fset.PositionFor(f.Pos(), false).Filename g, ok := isGenerated(path) if ok { m[path] = g } } return m, nil }, RunDespiteErrors: true, ResultType: reflect.TypeOf(map[string]Generator{}), } golang-honnef-go-tools-2024.1/analysis/facts/nilness/000077500000000000000000000000001465704072200224725ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/nilness/nilness.go000066400000000000000000000145701465704072200245030ustar00rootroot00000000000000package nilness import ( "fmt" "go/token" "go/types" "reflect" "honnef.co/go/tools/go/ir" "honnef.co/go/tools/go/types/typeutil" "honnef.co/go/tools/internal/passes/buildir" "golang.org/x/tools/go/analysis" ) // neverReturnsNilFact denotes that a function's return value will never // be nil (typed or untyped). The analysis errs on the side of false // negatives. type neverReturnsNilFact struct { Rets []neverNilness } func (*neverReturnsNilFact) AFact() {} func (fact *neverReturnsNilFact) String() string { return fmt.Sprintf("never returns nil: %v", fact.Rets) } type Result struct { m map[*types.Func][]neverNilness } var Analysis = &analysis.Analyzer{ Name: "nilness", Doc: "Annotates return values that will never be nil (typed or untyped)", Run: run, Requires: []*analysis.Analyzer{buildir.Analyzer}, FactTypes: []analysis.Fact{(*neverReturnsNilFact)(nil)}, ResultType: reflect.TypeOf((*Result)(nil)), } // MayReturnNil reports whether the ret's return value of fn might be // a typed or untyped nil value. The value of ret is zero-based. When // globalOnly is true, the only possible nil values are global // variables. // // The analysis has false positives: MayReturnNil can incorrectly // report true, but never incorrectly reports false. func (r *Result) MayReturnNil(fn *types.Func, ret int) (yes bool, globalOnly bool) { if !typeutil.IsPointerLike(fn.Type().(*types.Signature).Results().At(ret).Type()) { return false, false } if len(r.m[fn]) == 0 { return true, false } v := r.m[fn][ret] return v != neverNil, v == onlyGlobal } func run(pass *analysis.Pass) (interface{}, error) { seen := map[*ir.Function]struct{}{} out := &Result{ m: map[*types.Func][]neverNilness{}, } for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs { impl(pass, fn, seen) } for _, fact := range pass.AllObjectFacts() { out.m[fact.Object.(*types.Func)] = fact.Fact.(*neverReturnsNilFact).Rets } return out, nil } type neverNilness uint8 const ( neverNil neverNilness = 1 onlyGlobal neverNilness = 2 nilly neverNilness = 3 ) func (n neverNilness) String() string { switch n { case neverNil: return "never" case onlyGlobal: return "global" case nilly: return "nil" default: return "BUG" } } func impl(pass *analysis.Pass, fn *ir.Function, seenFns map[*ir.Function]struct{}) []neverNilness { if fn.Object() == nil { // TODO(dh): support closures return nil } if fact := new(neverReturnsNilFact); pass.ImportObjectFact(fn.Object(), fact) { return fact.Rets } if fn.Pkg != pass.ResultOf[buildir.Analyzer].(*buildir.IR).Pkg { return nil } if fn.Blocks == nil { return nil } if _, ok := seenFns[fn]; ok { // break recursion return nil } seenFns[fn] = struct{}{} seen := map[ir.Value]struct{}{} var mightReturnNil func(v ir.Value) neverNilness mightReturnNil = func(v ir.Value) neverNilness { if _, ok := seen[v]; ok { // break cycle return nilly } if !typeutil.IsPointerLike(v.Type()) { return neverNil } seen[v] = struct{}{} switch v := v.(type) { case *ir.MakeInterface: return mightReturnNil(v.X) case *ir.Convert: return mightReturnNil(v.X) case *ir.SliceToArrayPointer: if typeutil.CoreType(v.Type()).(*types.Pointer).Elem().Underlying().(*types.Array).Len() == 0 { return mightReturnNil(v.X) } else { // converting a slice to an array pointer of length > 0 panics if the slice is nil return neverNil } case *ir.Slice: return mightReturnNil(v.X) case *ir.Phi: ret := neverNil for _, e := range v.Edges { if n := mightReturnNil(e); n > ret { ret = n } } return ret case *ir.Extract: switch d := v.Tuple.(type) { case *ir.Call: if callee := d.Call.StaticCallee(); callee != nil { ret := impl(pass, callee, seenFns) if len(ret) == 0 { return nilly } return ret[v.Index] } else { return nilly } case *ir.TypeAssert, *ir.Next, *ir.Select, *ir.MapLookup, *ir.TypeSwitch, *ir.Recv, *ir.Sigma: // we don't need to look at the Extract's index // because we've already checked its type. return nilly default: panic(fmt.Sprintf("internal error: unhandled type %T", d)) } case *ir.Call: if callee := v.Call.StaticCallee(); callee != nil { ret := impl(pass, callee, seenFns) if len(ret) == 0 { return nilly } return ret[0] } else { return nilly } case *ir.BinOp, *ir.UnOp, *ir.Alloc, *ir.FieldAddr, *ir.IndexAddr, *ir.Global, *ir.MakeSlice, *ir.MakeClosure, *ir.Function, *ir.MakeMap, *ir.MakeChan: return neverNil case *ir.Sigma: iff, ok := v.From.Control().(*ir.If) if !ok { return nilly } binop, ok := iff.Cond.(*ir.BinOp) if !ok { return nilly } isNil := func(v ir.Value) bool { k, ok := v.(*ir.Const) if !ok { return false } return k.Value == nil } if binop.X == v.X && isNil(binop.Y) || binop.Y == v.X && isNil(binop.X) { op := binop.Op if v.From.Succs[0] != v.Block() { // we're in the false branch, negate op switch op { case token.EQL: op = token.NEQ case token.NEQ: op = token.EQL default: panic(fmt.Sprintf("internal error: unhandled token %v", op)) } } switch op { case token.EQL: return nilly case token.NEQ: return neverNil default: panic(fmt.Sprintf("internal error: unhandled token %v", op)) } } return nilly case *ir.ChangeType: return mightReturnNil(v.X) case *ir.MultiConvert: return mightReturnNil(v.X) case *ir.Load: if _, ok := v.X.(*ir.Global); ok { return onlyGlobal } return nilly case *ir.AggregateConst: return neverNil case *ir.TypeAssert, *ir.ChangeInterface, *ir.Field, *ir.Const, *ir.GenericConst, *ir.Index, *ir.MapLookup, *ir.Parameter, *ir.Recv, *ir.TypeSwitch: return nilly default: panic(fmt.Sprintf("internal error: unhandled type %T", v)) } } ret := fn.Exit.Control().(*ir.Return) out := make([]neverNilness, len(ret.Results)) export := false for i, v := range ret.Results { // OPT(dh): couldn't we check the result type's pointer-likeness early, and skip // processing the return value altogether? v := mightReturnNil(v) out[i] = v if v != nilly && typeutil.IsPointerLike(fn.Signature.Results().At(i).Type()) { export = true } } if export { pass.ExportObjectFact(fn.Object(), &neverReturnsNilFact{out}) } return out } golang-honnef-go-tools-2024.1/analysis/facts/nilness/nilness_test.go000066400000000000000000000003121465704072200255270ustar00rootroot00000000000000package nilness import ( "testing" "golang.org/x/tools/go/analysis/analysistest" ) func TestNilness(t *testing.T) { analysistest.Run(t, analysistest.TestData(), Analysis, "example.com/Nilness") } golang-honnef-go-tools-2024.1/analysis/facts/nilness/testdata/000077500000000000000000000000001465704072200243035ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/nilness/testdata/src/000077500000000000000000000000001465704072200250725ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/nilness/testdata/src/example.com/000077500000000000000000000000001465704072200273025ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/nilness/testdata/src/example.com/Nilness/000077500000000000000000000000001465704072200307155ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/nilness/testdata/src/example.com/Nilness/Nilness.go000066400000000000000000000031301465704072200326540ustar00rootroot00000000000000package pkg import "errors" type T struct{ f *int } type T2 T func fn1() *T { if true { return nil } return &T{} } func fn2() *T { // want fn2:`never returns nil: \[never\]` return &T{} } func fn3() *T { // want fn3:`never returns nil: \[never\]` return new(T) } func fn4() *T { // want fn4:`never returns nil: \[never\]` return fn3() } func fn5() *T { return fn1() } func fn6() *T2 { // want fn6:`never returns nil: \[never\]` return (*T2)(fn4()) } func fn7() interface{} { return nil } func fn8() interface{} { // want fn8:`never returns nil: \[never\]` return 1 } func fn9() []int { // want fn9:`never returns nil: \[never\]` x := []int{} y := x[:1] return y } func fn10(x []int) []int { return x[:1] } func fn11(x *T) *T { return x } func fn12(x *T) *int { return x.f } func fn13() *int { // want fn13:`never returns nil: \[never\]` return new(int) } func fn14() []int { // want fn14:`never returns nil: \[never\]` return make([]int, 0) } func fn15() []int { // want fn15:`never returns nil: \[never\]` return []int{} } func fn16() []int { return nil } func fn17() error { if true { return errors.New("") } return nil } func fn18() (err error) { // want fn18:`never returns nil: \[never\]` for { if err = fn17(); err != nil { return } } } var x *int func fn19() *int { // want fn19:`never returns nil: \[global\]` return x } func fn20() *int { if true { return x } return nil } func fn27[T ~struct{ F int }]() T { return T{0} } func fn28[T [8]int]() T { return T{} } func fn29[T []int]() T { // want fn29:`never returns nil: \[never\]` return T{} } Nilness_go118.go000066400000000000000000000021631465704072200335210ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/nilness/testdata/src/example.com/Nilness//go:build go1.18 package pkg // Make sure we don't crash upon seeing a MultiConvert instruction. func generic1[T []byte | string](s T) T { switch v := any(s).(type) { case string: return T(v) case []byte: return T(v) default: return s } } // Make sure we don't emit a fact for a function whose return type isn't pointer-like. func generic2[T [4]byte | string](s T) T { switch v := any(s).(type) { case string: return T([]byte(v)) case [4]byte: return T(v[:]) default: return s } } // Make sure we detect that the return value cannot be nil. It is either a string, a // non-nil slice we got passed, or a non-nil slice we allocate. Note that we don't // understand that the switch's non-default branches are exhaustive over the type set and // for the fact to be computed, we have to return something non-nil from the unreachable // default branch. func generic3[T []byte | string](s T) T { // want generic3:`never returns nil: \[never\]` switch v := any(s).(type) { case string: return T(v) case []byte: if v == nil { return T([]byte{}) } else { return T(v) } default: return T([]byte{}) } } Nilness_go17.go000066400000000000000000000011541465704072200334360ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/nilness/testdata/src/example.com/Nilness//go:build go1.17 // +build go1.17 package pkg func fn21() *[5]int { // want fn21:`never returns nil: \[never\]` var x []int return (*[5]int)(x) } func fn22() *[0]int { var x []int return (*[0]int)(x) } func fn23() *[5]int { // want fn23:`never returns nil: \[never\]` var x []int type T [5]int ret := (*T)(x) return (*[5]int)(ret) } func fn24() *[0]int { var x []int type T [0]int ret := (*T)(x) return (*[0]int)(ret) } func fn25() *[5]int { // want fn25:`never returns nil: \[never\]` var x []int type T *[5]int return (T)(x) } func fn26() *[0]int { var x []int type T *[0]int return (T)(x) } golang-honnef-go-tools-2024.1/analysis/facts/purity/000077500000000000000000000000001465704072200223535ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/purity/purity.go000066400000000000000000000156751465704072200242540ustar00rootroot00000000000000package purity // TODO(dh): we should split this into two facts, one tracking actual purity, and one tracking side-effects. A function // that returns a heap allocation isn't pure, but it may be free of side effects. import ( "go/types" "reflect" "honnef.co/go/tools/go/ir" "honnef.co/go/tools/go/ir/irutil" "honnef.co/go/tools/internal/passes/buildir" "golang.org/x/tools/go/analysis" ) type IsPure struct{} func (*IsPure) AFact() {} func (d *IsPure) String() string { return "is pure" } type Result map[*types.Func]*IsPure var Analyzer = &analysis.Analyzer{ Name: "fact_purity", Doc: "Mark pure functions", Run: purity, Requires: []*analysis.Analyzer{buildir.Analyzer}, FactTypes: []analysis.Fact{(*IsPure)(nil)}, ResultType: reflect.TypeOf(Result{}), } var pureStdlib = map[string]struct{}{ "errors.New": {}, "fmt.Errorf": {}, "fmt.Sprintf": {}, "fmt.Sprint": {}, "sort.Reverse": {}, "strings.Map": {}, "strings.Repeat": {}, "strings.Replace": {}, "strings.Title": {}, "strings.ToLower": {}, "strings.ToLowerSpecial": {}, "strings.ToTitle": {}, "strings.ToTitleSpecial": {}, "strings.ToUpper": {}, "strings.ToUpperSpecial": {}, "strings.Trim": {}, "strings.TrimFunc": {}, "strings.TrimLeft": {}, "strings.TrimLeftFunc": {}, "strings.TrimPrefix": {}, "strings.TrimRight": {}, "strings.TrimRightFunc": {}, "strings.TrimSpace": {}, "strings.TrimSuffix": {}, "(*net/http.Request).WithContext": {}, "time.Now": {}, "time.Parse": {}, "time.ParseInLocation": {}, "time.Unix": {}, "time.UnixMicro": {}, "time.UnixMilli": {}, "(time.Time).Add": {}, "(time.Time).AddDate": {}, "(time.Time).After": {}, "(time.Time).Before": {}, "(time.Time).Clock": {}, "(time.Time).Compare": {}, "(time.Time).Date": {}, "(time.Time).Day": {}, "(time.Time).Equal": {}, "(time.Time).Format": {}, "(time.Time).GoString": {}, "(time.Time).GobEncode": {}, "(time.Time).Hour": {}, "(time.Time).ISOWeek": {}, "(time.Time).In": {}, "(time.Time).IsDST": {}, "(time.Time).IsZero": {}, "(time.Time).Local": {}, "(time.Time).Location": {}, "(time.Time).MarshalBinary": {}, "(time.Time).MarshalJSON": {}, "(time.Time).MarshalText": {}, "(time.Time).Minute": {}, "(time.Time).Month": {}, "(time.Time).Nanosecond": {}, "(time.Time).Round": {}, "(time.Time).Second": {}, "(time.Time).String": {}, "(time.Time).Sub": {}, "(time.Time).Truncate": {}, "(time.Time).UTC": {}, "(time.Time).Unix": {}, "(time.Time).UnixMicro": {}, "(time.Time).UnixMilli": {}, "(time.Time).UnixNano": {}, "(time.Time).Weekday": {}, "(time.Time).Year": {}, "(time.Time).YearDay": {}, "(time.Time).Zone": {}, "(time.Time).ZoneBounds": {}, } func purity(pass *analysis.Pass) (interface{}, error) { seen := map[*ir.Function]struct{}{} irpkg := pass.ResultOf[buildir.Analyzer].(*buildir.IR).Pkg var check func(fn *ir.Function) (ret bool) check = func(fn *ir.Function) (ret bool) { if fn.Object() == nil { // TODO(dh): support closures return false } if pass.ImportObjectFact(fn.Object(), new(IsPure)) { return true } if fn.Pkg != irpkg { // Function is in another package but wasn't marked as // pure, ergo it isn't pure return false } // Break recursion if _, ok := seen[fn]; ok { return false } seen[fn] = struct{}{} defer func() { if ret { pass.ExportObjectFact(fn.Object(), &IsPure{}) } }() if irutil.IsStub(fn) { return false } if _, ok := pureStdlib[fn.Object().(*types.Func).FullName()]; ok { return true } if fn.Signature.Results().Len() == 0 { // A function with no return values is empty or is doing some // work we cannot see (for example because of build tags); // don't consider it pure. return false } var isBasic func(typ types.Type) bool isBasic = func(typ types.Type) bool { switch u := typ.Underlying().(type) { case *types.Basic: return true case *types.Struct: for i := 0; i < u.NumFields(); i++ { if !isBasic(u.Field(i).Type()) { return false } } return true default: return false } } for _, param := range fn.Params { // TODO(dh): this may not be strictly correct. pure code can, to an extent, operate on non-basic types. if !isBasic(param.Type()) { return false } } // Don't consider external functions pure. if fn.Blocks == nil { return false } checkCall := func(common *ir.CallCommon) bool { if common.IsInvoke() { return false } builtin, ok := common.Value.(*ir.Builtin) if !ok { if common.StaticCallee() != fn { if common.StaticCallee() == nil { return false } if !check(common.StaticCallee()) { return false } } } else { switch builtin.Name() { case "len", "cap": default: return false } } return true } var isStackAddr func(ir.Value) bool isStackAddr = func(v ir.Value) bool { switch v := v.(type) { case *ir.Alloc: return !v.Heap case *ir.FieldAddr: return isStackAddr(v.X) default: return false } } for _, b := range fn.Blocks { for _, ins := range b.Instrs { switch ins := ins.(type) { case *ir.Call: if !checkCall(ins.Common()) { return false } case *ir.Defer: if !checkCall(&ins.Call) { return false } case *ir.Select: return false case *ir.Send: return false case *ir.Go: return false case *ir.Panic: return false case *ir.Store: if !isStackAddr(ins.Addr) { return false } case *ir.FieldAddr: if !isStackAddr(ins.X) { return false } case *ir.Alloc: // TODO(dh): make use of proper escape analysis if ins.Heap { return false } case *ir.Load: if !isStackAddr(ins.X) { return false } } } } return true } for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs { check(fn) } out := Result{} for _, fact := range pass.AllObjectFacts() { out[fact.Object.(*types.Func)] = fact.Fact.(*IsPure) } return out, nil } golang-honnef-go-tools-2024.1/analysis/facts/purity/purity_test.go000066400000000000000000000003071465704072200252750ustar00rootroot00000000000000package purity import ( "testing" "golang.org/x/tools/go/analysis/analysistest" ) func TestPurity(t *testing.T) { analysistest.Run(t, analysistest.TestData(), Analyzer, "example.com/Purity") } golang-honnef-go-tools-2024.1/analysis/facts/purity/testdata/000077500000000000000000000000001465704072200241645ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/purity/testdata/src/000077500000000000000000000000001465704072200247535ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/purity/testdata/src/example.com/000077500000000000000000000000001465704072200271635ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/purity/testdata/src/example.com/Purity/000077500000000000000000000000001465704072200304575ustar00rootroot00000000000000CheckPureFunctions.go000066400000000000000000000012731465704072200344740ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/purity/testdata/src/example.com/Puritypackage pkg func foo(a, b int) int { return a + b } // want foo:"is pure" func bar(a, b int) int { println(a + b) return a + b } func empty() {} func stubPointer() *int { return nil } func stubInt() int { return 0 } func fn3() { empty() stubPointer() stubInt() } func ptr1() *int { return new(int) } func ptr2() *int { var x int; return &x } func lit() []int { return []int{} } var X int func load() int { _ = X; return 0 } func assign(x int) int { _ = x; return 0 } // want assign:"is pure" type pureStruct1 struct { a int b string pureStruct2 } type pureStruct2 struct { c float64 } func (arg pureStruct1) get() int { // want get:"is pure" return arg.a } golang-honnef-go-tools-2024.1/analysis/facts/tokenfile/000077500000000000000000000000001465704072200227775ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/tokenfile/token.go000066400000000000000000000007711465704072200244530ustar00rootroot00000000000000package tokenfile import ( "go/ast" "go/token" "reflect" "golang.org/x/tools/go/analysis" ) var Analyzer = &analysis.Analyzer{ Name: "tokenfileanalyzer", Doc: "creates a mapping of *token.File to *ast.File", Run: func(pass *analysis.Pass) (interface{}, error) { m := map[*token.File]*ast.File{} for _, af := range pass.Files { tf := pass.Fset.File(af.Pos()) m[tf] = af } return m, nil }, RunDespiteErrors: true, ResultType: reflect.TypeOf(map[*token.File]*ast.File{}), } golang-honnef-go-tools-2024.1/analysis/facts/typedness/000077500000000000000000000000001465704072200230355ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/typedness/testdata/000077500000000000000000000000001465704072200246465ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/typedness/testdata/src/000077500000000000000000000000001465704072200254355ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/typedness/testdata/src/example.com/000077500000000000000000000000001465704072200276455ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/typedness/testdata/src/example.com/Typedness/000077500000000000000000000000001465704072200316235ustar00rootroot00000000000000Typedness.go000066400000000000000000000102411465704072200340470ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/facts/typedness/testdata/src/example.com/Typednesspackage pkg import ( "errors" "os/exec" ) type T struct{ x *int } func notAStub() {} func fn1() *int { return nil } func fn2() (int, *int, int) { return 0, nil, 0 } func fn3() (out1 int, out2 error) { notAStub(); return 0, nil } func fn4() error { notAStub(); return nil } func gen2() (out1 interface{}) { // want gen2:`always typed: 00000001` return 1 } func gen3() (out1 interface{}) { // want gen3:`always typed: 00000001` // flag, always returns a typed value m := map[int]*int{} return m[0] } func gen4() (out1 int, out2 interface{}, out3 *int) { // want gen4:`always typed: 00000010` // flag ret[1], always a typed value m := map[int]*int{} return 0, m[0], nil } func gen5() (out1 interface{}) { // want gen5:`always typed: 00000001` // flag, propagate gen3 return gen3() } func gen6(b bool) interface{} { // don't flag, sometimes returns untyped nil if b { m := map[int]*int{} return m[0] } else { return nil } } func gen7() (out1 interface{}) { // want gen7:`always typed: 00000001` // flag, always returns a typed value return fn1() } func gen8(x *int) (out1 interface{}) { // want gen8:`always typed: 00000001` // flag if x == nil { return x } return x } func gen9() (out1 interface{}) { // want gen9:`always typed: 00000001` // flag var x *int return x } func gen10() (out1 interface{}) { // want gen10:`always typed: 00000001` // flag var x *int if x == nil { return x } return errors.New("") } func gen11() interface{} { // don't flag, we sometimes return untyped nil if true { return nil } else { return (*int)(nil) } } func gen12(b bool) (out1 interface{}) { // want gen12:`always typed: 00000001` // flag, all branches return typed nils var x interface{} if b { x = (*int)(nil) } else { x = (*string)(nil) } return x } func gen13() (out1 interface{}) { // want gen13:`always typed: 00000001` // flag, always returns a typed value _, x, _ := fn2() return x } func gen14(ch chan *int) (out1 interface{}) { // want gen14:`always typed: 00000001` // flag return <-ch } func gen15() (out1 interface{}) { // want gen15:`always typed: 00000001` // flag t := &T{} return t.x } var g *int = new(int) func gen16() (out1 interface{}) { // want gen16:`always typed: 00000001` return g } func gen17(x interface{}) interface{} { // don't flag if x != nil { return x } return x } func gen18() (int, error) { // don't flag _, err := fn3() if err != nil { return 0, errors.New("yo") } return 0, err } func gen19() (out interface{}) { // don't flag if true { return (*int)(nil) } return } func gen20() (out interface{}) { // don't flag if true { return (*int)(nil) } return } func gen21() error { if false { return (*exec.Error)(nil) } return fn4() } func gen22() interface{} { // don't flag, propagate gen6 return gen6(false) } func gen23() interface{} { return gen24() } func gen24() interface{} { return gen23() } func gen25(x interface{}) (out1 interface{}) { // want gen25:`always typed: 00000001` return x.(interface{}) } func gen26(x interface{}) interface{} { v, _ := x.(interface{}) return v } func gen27(x interface{}) (out1 interface{}) { defer recover() out1 = x.(interface{}) return out1 } type Error struct{} func (*Error) Error() string { return "" } func gen28() (out1 interface{}) { // want gen28:`always typed: 00000001` x := new(Error) var y error = x return y } func gen29() (out1 interface{}) { // want gen29:`always typed: 00000001` var x *Error var y error = x return y } func gen30() (out1, out2 interface{}) { // want gen30:`always typed: 00000011` return gen29(), gen28() } func gen31() (out1 interface{}) { // want gen31:`always typed: 00000001` a, _ := gen30() return a } func gen32() (out1 interface{}) { // want gen32:`always typed: 00000001` _, b := gen30() return b } func gen33() (out1 interface{}) { // want gen33:`always typed: 00000001` a, b := gen30() _ = a return b } func gen34() (out1, out2 interface{}) { // want gen34:`always typed: 00000010` return nil, 1 } func gen35() (out1 interface{}) { a, _ := gen34() return a } func gen36() (out1 interface{}) { // want gen36:`always typed: 00000001` _, b := gen34() return b } golang-honnef-go-tools-2024.1/analysis/facts/typedness/typedness.go000066400000000000000000000155231465704072200254100ustar00rootroot00000000000000package typedness import ( "fmt" "go/token" "go/types" "reflect" "honnef.co/go/tools/go/ir" "honnef.co/go/tools/go/ir/irutil" "honnef.co/go/tools/internal/passes/buildir" "golang.org/x/exp/typeparams" "golang.org/x/tools/go/analysis" ) // alwaysTypedFact denotes that a function's return value will never // be untyped nil. The analysis errs on the side of false negatives. type alwaysTypedFact struct { Rets uint8 } func (*alwaysTypedFact) AFact() {} func (fact *alwaysTypedFact) String() string { return fmt.Sprintf("always typed: %08b", fact.Rets) } type Result struct { m map[*types.Func]uint8 } var Analysis = &analysis.Analyzer{ Name: "typedness", Doc: "Annotates return values that are always typed values", Run: run, Requires: []*analysis.Analyzer{buildir.Analyzer}, FactTypes: []analysis.Fact{(*alwaysTypedFact)(nil)}, ResultType: reflect.TypeOf((*Result)(nil)), } // MustReturnTyped reports whether the ret's return value of fn must // be a typed value, i.e. an interface value containing a concrete // type or trivially a concrete type. The value of ret is zero-based. // // The analysis has false negatives: MustReturnTyped may incorrectly // report false, but never incorrectly reports true. func (r *Result) MustReturnTyped(fn *types.Func, ret int) bool { if _, ok := fn.Type().(*types.Signature).Results().At(ret).Type().Underlying().(*types.Interface); !ok { return true } return (r.m[fn] & (1 << ret)) != 0 } func run(pass *analysis.Pass) (interface{}, error) { seen := map[*ir.Function]struct{}{} out := &Result{ m: map[*types.Func]uint8{}, } for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs { impl(pass, fn, seen) } for _, fact := range pass.AllObjectFacts() { out.m[fact.Object.(*types.Func)] = fact.Fact.(*alwaysTypedFact).Rets } return out, nil } func impl(pass *analysis.Pass, fn *ir.Function, seenFns map[*ir.Function]struct{}) (out uint8) { if fn.Signature.Results().Len() > 8 { return 0 } if fn.Object() == nil { // TODO(dh): support closures return 0 } if fact := new(alwaysTypedFact); pass.ImportObjectFact(fn.Object(), fact) { return fact.Rets } if fn.Pkg != pass.ResultOf[buildir.Analyzer].(*buildir.IR).Pkg { return 0 } if fn.Blocks == nil { return 0 } if irutil.IsStub(fn) { return 0 } if _, ok := seenFns[fn]; ok { // break recursion return 0 } seenFns[fn] = struct{}{} defer func() { for i := 0; i < fn.Signature.Results().Len(); i++ { if _, ok := fn.Signature.Results().At(i).Type().Underlying().(*types.Interface); !ok { // we don't need facts to know that non-interface // types can't be untyped nil. zeroing out those bits // may result in all bits being zero, in which case we // don't have to save any fact. out &= ^(1 << i) } } if out > 0 { pass.ExportObjectFact(fn.Object(), &alwaysTypedFact{out}) } }() isUntypedNil := func(v ir.Value) bool { k, ok := v.(*ir.Const) if !ok { return false } if _, ok := k.Type().Underlying().(*types.Interface); !ok { return false } return k.Value == nil } var do func(v ir.Value, seen map[ir.Value]struct{}) bool do = func(v ir.Value, seen map[ir.Value]struct{}) bool { if _, ok := seen[v]; ok { // break cycle return false } seen[v] = struct{}{} switch v := v.(type) { case *ir.Const: // can't be a typed nil, because then we'd be returning the // result of MakeInterface. return false case *ir.ChangeInterface: return do(v.X, seen) case *ir.Extract: call, ok := v.Tuple.(*ir.Call) if !ok { // We only care about extracts of function results. For // everything else (e.g. channel receives and map // lookups), we can either not deduce any information, or // will see a MakeInterface. return false } if callee := call.Call.StaticCallee(); callee != nil { return impl(pass, callee, seenFns)&(1<interface conversions, which // don't tell us anything about the nilness. return false case *ir.MapLookup, *ir.Index, *ir.Recv, *ir.Parameter, *ir.Load, *ir.Field: // All other instructions that tell us nothing about the // typedness of interface values. return false default: panic(fmt.Sprintf("internal error: unhandled type %T", v)) } } ret := fn.Exit.Control().(*ir.Return) for i, v := range ret.Results { typ := fn.Signature.Results().At(i).Type() if _, ok := typ.Underlying().(*types.Interface); ok && !typeparams.IsTypeParam(typ) { if do(v, map[ir.Value]struct{}{}) { out |= 1 << i } } } return out } golang-honnef-go-tools-2024.1/analysis/facts/typedness/typedness_test.go000066400000000000000000000003201465704072200264340ustar00rootroot00000000000000package typedness import ( "testing" "golang.org/x/tools/go/analysis/analysistest" ) func TestTypedness(t *testing.T) { analysistest.Run(t, analysistest.TestData(), Analysis, "example.com/Typedness") } golang-honnef-go-tools-2024.1/analysis/lint/000077500000000000000000000000001465704072200206655ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/lint/lint.go000066400000000000000000000123041465704072200221620ustar00rootroot00000000000000// Package lint provides abstractions on top of go/analysis. // These abstractions add extra information to analyzes, such as structured documentation and severities. package lint import ( "fmt" "go/ast" "go/token" "strings" "golang.org/x/tools/go/analysis" "honnef.co/go/tools/analysis/facts/tokenfile" ) // Analyzer wraps a go/analysis.Analyzer and provides structured documentation. type Analyzer struct { // The analyzer's documentation. Unlike go/analysis.Analyzer.Doc, // this field is structured, providing access to severity, options // etc. Doc *RawDocumentation Analyzer *analysis.Analyzer } func InitializeAnalyzer(a *Analyzer) *Analyzer { a.Analyzer.Doc = a.Doc.Compile().String() a.Analyzer.URL = "https://staticcheck.dev/docs/checks/#" + a.Analyzer.Name a.Analyzer.Requires = append(a.Analyzer.Requires, tokenfile.Analyzer) return a } // Severity describes the severity of diagnostics reported by an analyzer. type Severity int const ( SeverityNone Severity = iota SeverityError SeverityDeprecated SeverityWarning SeverityInfo SeverityHint ) // MergeStrategy sets how merge mode should behave for diagnostics of an analyzer. type MergeStrategy int const ( MergeIfAny MergeStrategy = iota MergeIfAll ) type RawDocumentation struct { Title string Text string Before string After string Since string NonDefault bool Options []string Severity Severity MergeIf MergeStrategy } type Documentation struct { Title string Text string TitleMarkdown string TextMarkdown string Before string After string Since string NonDefault bool Options []string Severity Severity MergeIf MergeStrategy } func (doc RawDocumentation) Compile() *Documentation { return &Documentation{ Title: strings.TrimSpace(stripMarkdown(doc.Title)), Text: strings.TrimSpace(stripMarkdown(doc.Text)), TitleMarkdown: strings.TrimSpace(toMarkdown(doc.Title)), TextMarkdown: strings.TrimSpace(toMarkdown(doc.Text)), Before: strings.TrimSpace(doc.Before), After: strings.TrimSpace(doc.After), Since: doc.Since, NonDefault: doc.NonDefault, Options: doc.Options, Severity: doc.Severity, MergeIf: doc.MergeIf, } } func toMarkdown(s string) string { return strings.NewReplacer(`\'`, "`", `\"`, "`").Replace(s) } func stripMarkdown(s string) string { return strings.NewReplacer(`\'`, "", `\"`, "'").Replace(s) } func (doc *Documentation) Format(metadata bool) string { return doc.format(false, metadata) } func (doc *Documentation) FormatMarkdown(metadata bool) string { return doc.format(true, metadata) } func (doc *Documentation) format(markdown bool, metadata bool) string { b := &strings.Builder{} if markdown { fmt.Fprintf(b, "%s\n\n", doc.TitleMarkdown) if doc.Text != "" { fmt.Fprintf(b, "%s\n\n", doc.TextMarkdown) } } else { fmt.Fprintf(b, "%s\n\n", doc.Title) if doc.Text != "" { fmt.Fprintf(b, "%s\n\n", doc.Text) } } if doc.Before != "" { fmt.Fprintln(b, "Before:") fmt.Fprintln(b, "") for _, line := range strings.Split(doc.Before, "\n") { fmt.Fprint(b, " ", line, "\n") } fmt.Fprintln(b, "") fmt.Fprintln(b, "After:") fmt.Fprintln(b, "") for _, line := range strings.Split(doc.After, "\n") { fmt.Fprint(b, " ", line, "\n") } fmt.Fprintln(b, "") } if metadata { fmt.Fprint(b, "Available since\n ") if doc.Since == "" { fmt.Fprint(b, "unreleased") } else { fmt.Fprintf(b, "%s", doc.Since) } if doc.NonDefault { fmt.Fprint(b, ", non-default") } fmt.Fprint(b, "\n") if len(doc.Options) > 0 { fmt.Fprintf(b, "\nOptions\n") for _, opt := range doc.Options { fmt.Fprintf(b, " %s", opt) } fmt.Fprint(b, "\n") } } return b.String() } func (doc *Documentation) String() string { return doc.Format(true) } // ExhaustiveTypeSwitch panics when called. It can be used to ensure // that type switches are exhaustive. func ExhaustiveTypeSwitch(v interface{}) { panic(fmt.Sprintf("internal error: unhandled case %T", v)) } // A directive is a comment of the form '//lint: // [arguments...]'. It represents instructions to the static analysis // tool. type Directive struct { Command string Arguments []string Directive *ast.Comment Node ast.Node } func parseDirective(s string) (cmd string, args []string) { if !strings.HasPrefix(s, "//lint:") { return "", nil } s = strings.TrimPrefix(s, "//lint:") fields := strings.Split(s, " ") return fields[0], fields[1:] } // ParseDirectives extracts all directives from a list of Go files. func ParseDirectives(files []*ast.File, fset *token.FileSet) []Directive { var dirs []Directive for _, f := range files { // OPT(dh): in our old code, we skip all the comment map work if we // couldn't find any directives, benchmark if that's actually // worth doing cm := ast.NewCommentMap(fset, f, f.Comments) for node, cgs := range cm { for _, cg := range cgs { for _, c := range cg.List { if !strings.HasPrefix(c.Text, "//lint:") { continue } cmd, args := parseDirective(c.Text) d := Directive{ Command: cmd, Arguments: args, Directive: c, Node: node, } dirs = append(dirs, d) } } } } return dirs } golang-honnef-go-tools-2024.1/analysis/lint/testutil/000077500000000000000000000000001465704072200225425ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/lint/testutil/check.go000066400000000000000000000253051465704072200241530ustar00rootroot00000000000000// Copyright 2018 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. // This file is a modified copy of x/tools/go/analysis/analysistest/analysistest.go package testutil import ( "bytes" "fmt" "go/format" "go/token" "os" "path/filepath" "regexp" "sort" "strings" "testing" "honnef.co/go/tools/internal/diff/myers" "honnef.co/go/tools/lintcmd/runner" "golang.org/x/tools/go/expect" "golang.org/x/tools/txtar" ) func CheckSuggestedFixes(t *testing.T, diagnostics []runner.Diagnostic) { // Process each result (package) separately, matching up the suggested // fixes into a diff, which we will compare to the .golden file. We have // to do this per-result in case a file appears in two packages, such as in // packages with tests, where mypkg/a.go will appear in both mypkg and // mypkg.test. In that case, the analyzer may suggest the same set of // changes to a.go for each package. If we merge all the results, those // changes get doubly applied, which will cause conflicts or mismatches. // Validating the results separately means as long as the two analyses // don't produce conflicting suggestions for a single file, everything // should match up. // file -> message -> edits fileEdits := make(map[string]map[string][]runner.TextEdit) fileContents := make(map[string][]byte) // Validate edits, prepare the fileEdits map and read the file contents. for _, diag := range diagnostics { for _, sf := range diag.SuggestedFixes { for _, edit := range sf.TextEdits { // Validate the edit. if edit.Position.Offset > edit.End.Offset { t.Errorf( "diagnostic for analysis %v contains Suggested Fix with malformed edit: pos (%v) > end (%v)", diag.Category, edit.Position.Offset, edit.End.Offset) continue } if edit.Position.Filename != edit.End.Filename { t.Errorf( "diagnostic for analysis %v contains Suggested Fix with malformed edit spanning files %v and %v", diag.Category, edit.Position.Filename, edit.End.Filename) continue } if _, ok := fileContents[edit.Position.Filename]; !ok { contents, err := os.ReadFile(edit.Position.Filename) if err != nil { t.Errorf("error reading %s: %v", edit.Position.Filename, err) } fileContents[edit.Position.Filename] = contents } if _, ok := fileEdits[edit.Position.Filename]; !ok { fileEdits[edit.Position.Filename] = make(map[string][]runner.TextEdit) } fileEdits[edit.Position.Filename][sf.Message] = append(fileEdits[edit.Position.Filename][sf.Message], edit) } } } for file, fixes := range fileEdits { // Get the original file contents. orig, ok := fileContents[file] if !ok { t.Errorf("could not find file contents for %s", file) continue } // Get the golden file and read the contents. ar, err := txtar.ParseFile(file + ".golden") if err != nil { t.Errorf("error reading %s.golden: %v", file, err) continue } if len(ar.Files) > 0 { // one virtual file per kind of suggested fix if len(ar.Comment) != 0 { // we allow either just the comment, or just virtual // files, not both. it is not clear how "both" should // behave. t.Errorf("%s.golden has leading comment; we don't know what to do with it", file) continue } var sfs []string for sf := range fixes { sfs = append(sfs, sf) } sort.Slice(sfs, func(i, j int) bool { return sfs[i] < sfs[j] }) for _, sf := range sfs { edits := fixes[sf] found := false for _, vf := range ar.Files { if vf.Name == sf { found = true out := applyEdits(orig, edits) // the file may contain multiple trailing // newlines if the user places empty lines // between files in the archive. normalize // this to a single newline. want := string(bytes.TrimRight(vf.Data, "\n")) + "\n" formatted, err := format.Source([]byte(out)) if err != nil { t.Errorf("%s: error formatting edited source: %v\n%s", file, err, out) continue } if want != string(formatted) { d := myers.ComputeEdits(want, string(formatted)) diff := "" for _, op := range d { diff += op.String() } t.Errorf("suggested fixes failed for %s[%s]:\n%s", file, sf, diff) } break } } if !found { t.Errorf("no section for suggested fix %q in %s.golden", sf, file) } } for _, vf := range ar.Files { if _, ok := fixes[vf.Name]; !ok { t.Errorf("%s.golden has section for suggested fix %q, but we didn't produce any fix by that name", file, vf.Name) } } } else { // all suggested fixes are represented by a single file var catchallEdits []runner.TextEdit for _, edits := range fixes { catchallEdits = append(catchallEdits, edits...) } out := applyEdits(orig, catchallEdits) want := string(ar.Comment) formatted, err := format.Source([]byte(out)) if err != nil { t.Errorf("%s: error formatting resulting source: %v\n%s", file, err, out) continue } if want != string(formatted) { d := myers.ComputeEdits(want, string(formatted)) diff := "" for _, op := range d { diff += op.String() } t.Errorf("suggested fixes failed for %s:\n%s", file, diff) } } } } func Check(t *testing.T, gopath string, files []string, diagnostics []runner.Diagnostic, facts []runner.TestFact) { relativePath := func(path string) string { cwd, err := os.Getwd() if err != nil { return path } rel, err := filepath.Rel(cwd, path) if err != nil { return path } return rel } type key struct { file string line int } // the 'files' argument contains a list of all files that were part of the tested package want := make(map[key][]*expect.Note) fset := token.NewFileSet() seen := map[string]struct{}{} for _, file := range files { seen[file] = struct{}{} notes, err := expect.Parse(fset, file, nil) if err != nil { t.Fatal(err) } for _, note := range notes { k := key{ file: file, line: fset.PositionFor(note.Pos, false).Line, } want[k] = append(want[k], note) } } for _, diag := range diagnostics { file := diag.Position.Filename if _, ok := seen[file]; !ok { t.Errorf("got diagnostic in file %q, but that file isn't part of the checked package", relativePath(file)) return } } check := func(posn token.Position, message string, kind string, argIdx int, identifier string) { k := key{posn.Filename, posn.Line} expects := want[k] var unmatched []string for i, exp := range expects { if exp.Name == kind { if kind == "fact" && exp.Args[0] != expect.Identifier(identifier) { continue } matched := false switch arg := exp.Args[argIdx].(type) { case string: matched = strings.Contains(message, arg) case *regexp.Regexp: matched = arg.MatchString(message) default: t.Fatalf("unexpected argument type %T", arg) } if matched { // matched: remove the expectation. expects[i] = expects[len(expects)-1] expects = expects[:len(expects)-1] want[k] = expects return } unmatched = append(unmatched, fmt.Sprintf("%q", exp.Args[argIdx])) } } if unmatched == nil { posn.Filename = relativePath(posn.Filename) t.Errorf("%v: unexpected diag: %v", posn, message) } else { posn.Filename = relativePath(posn.Filename) t.Errorf("%v: diag %q does not match pattern %s", posn, message, strings.Join(unmatched, " or ")) } } checkDiag := func(posn token.Position, message string) { check(posn, message, "diag", 0, "") } checkFact := func(posn token.Position, name, message string) { check(posn, message, "fact", 1, name) } // Check the diagnostics match expectations. for _, f := range diagnostics { // TODO(matloob): Support ranges in analysistest. posn := f.Position checkDiag(posn, f.Message) } // Check the facts match expectations. for _, fact := range facts { name := fact.ObjectName posn := fact.Position if name == "" { name = "package" posn.Line = 1 } checkFact(posn, name, fact.FactString) } // Reject surplus expectations. // // Sometimes an Analyzer reports two similar diagnostics on a // line with only one expectation. The reader may be confused by // the error message. // TODO(adonovan): print a better error: // "got 2 diagnostics here; each one needs its own expectation". var surplus []string for key, expects := range want { for _, exp := range expects { surplus = append(surplus, fmt.Sprintf("%s:%d: no %s was reported matching %q", relativePath(key.file), key.line, exp.Name, exp.Args)) } } sort.Strings(surplus) for _, err := range surplus { t.Errorf("%s", err) } } func applyEdits(src []byte, edits []runner.TextEdit) []byte { // This function isn't efficient, but it doesn't have to be. edits = append([]runner.TextEdit(nil), edits...) sort.Slice(edits, func(i, j int) bool { if edits[i].Position.Offset < edits[j].Position.Offset { return true } if edits[i].Position.Offset == edits[j].Position.Offset { return edits[i].End.Offset < edits[j].End.Offset } return false }) out := append([]byte(nil), src...) offset := 0 for _, edit := range edits { start := edit.Position.Offset + offset end := edit.End.Offset + offset if edit.End == (token.Position{}) { end = -1 } if len(edit.NewText) == 0 { // pure deletion copy(out[start:], out[end:]) out = out[:len(out)-(end-start)] offset -= end - start } else if end == -1 || end == start { // pure insertion tmp := make([]byte, len(out)+len(edit.NewText)) copy(tmp, out[:start]) copy(tmp[start:], edit.NewText) copy(tmp[start+len(edit.NewText):], out[start:]) offset += len(edit.NewText) out = tmp } else if end-start == len(edit.NewText) { // exact replacement copy(out[start:], edit.NewText) } else if end-start < len(edit.NewText) { // replace with longer string growth := len(edit.NewText) - (end - start) tmp := make([]byte, len(out)+growth) copy(tmp, out[:start]) copy(tmp[start:], edit.NewText) copy(tmp[start+len(edit.NewText):], out[end:]) offset += growth out = tmp } else if end-start > len(edit.NewText) { // replace with shorter string shrinkage := (end - start) - len(edit.NewText) copy(out[start:], edit.NewText) copy(out[start+len(edit.NewText):], out[end:]) out = out[:len(out)-shrinkage] offset -= shrinkage } } // Debug code if false { fmt.Println("input:") fmt.Println(string(src)) fmt.Println() fmt.Println("edits:") for _, edit := range edits { fmt.Printf("%d:%d - %d:%d <- %q\n", edit.Position.Line, edit.Position.Column, edit.End.Line, edit.End.Column, edit.NewText) } fmt.Println("output:") fmt.Println(string(out)) panic("") } return out } golang-honnef-go-tools-2024.1/analysis/lint/testutil/util.go000066400000000000000000000062231465704072200240510ustar00rootroot00000000000000package testutil import ( "crypto/sha256" "go/build" "go/version" "io" "os" "path/filepath" "strings" "testing" "honnef.co/go/tools/analysis/lint" "honnef.co/go/tools/config" "honnef.co/go/tools/go/buildid" "honnef.co/go/tools/lintcmd/cache" "honnef.co/go/tools/lintcmd/runner" "golang.org/x/tools/go/analysis" "golang.org/x/tools/go/packages" ) type Test struct { Dir string Version string } func computeSalt() ([]byte, error) { p, err := os.Executable() if err != nil { return nil, err } if id, err := buildid.ReadFile(p); err == nil { return []byte(id), nil } else { // For some reason we couldn't read the build id from the executable. // Fall back to hashing the entire executable. f, err := os.Open(p) if err != nil { return nil, err } defer f.Close() h := sha256.New() if _, err := io.Copy(h, f); err != nil { return nil, err } return h.Sum(nil), nil } } func Run(t *testing.T, a *lint.Analyzer) { dirs, err := filepath.Glob("testdata/*") if err != nil { t.Fatalf("couldn't enumerate test data: %s", err) } if len(dirs) == 0 { t.Fatalf("found no tests") } c, err := cache.Open(t.TempDir()) if err != nil { t.Fatal(err) } salt, err := computeSalt() if err != nil { t.Fatal(err) } c.SetSalt(salt) tags := build.Default.ReleaseTags maxVersion := tags[len(tags)-1] for _, dir := range dirs { vers := filepath.Base(dir) t.Run(vers, func(t *testing.T) { if !version.IsValid(vers) { t.Fatalf("%q is not a valid Go version", dir) } if version.Compare(vers, maxVersion) == 1 { t.Skipf("%s is newer than our Go version (%s), skipping", vers, maxVersion) } r, err := runner.New(config.Config{}, c) if err != nil { t.Fatal(err) } r.TestMode = true testdata, err := filepath.Abs("testdata") if err != nil { t.Fatal(err) } cfg := &packages.Config{ Dir: dir, Tests: true, Env: append(os.Environ(), "GOPROXY=off", "GOFLAGS=-mod=vendor"), Overlay: map[string][]byte{ "go.mod": []byte("module example.com\ngo " + strings.TrimPrefix(vers, "go")), }, } res, err := r.Run(cfg, []*analysis.Analyzer{a.Analyzer}, []string{"./..."}) if err != nil { t.Fatal(err) } if len(res) == 0 { t.Fatalf("got no results for %s/...", dir) } for _, r := range res { if r.Failed { if len(r.Errors) > 0 { sb := strings.Builder{} for _, err := range r.Errors { sb.WriteString(err.Error()) sb.WriteString("\n") } t.Fatalf("failed checking %s:\n%s", r.Package.PkgPath, sb.String()) } else { t.Fatalf("failed processing package %s, but got no errors", r.Package.PkgPath) } } data, err := r.Load() if err != nil { t.Fatal(err) } tdata, err := r.LoadTest() if err != nil { t.Fatal(err) } relevantDiags := data.Diagnostics var relevantFacts []runner.TestFact for _, fact := range tdata.Facts { if fact.Analyzer != a.Analyzer.Name { continue } relevantFacts = append(relevantFacts, fact) } Check(t, testdata, tdata.Files, relevantDiags, relevantFacts) CheckSuggestedFixes(t, relevantDiags) } }) } } golang-honnef-go-tools-2024.1/analysis/report/000077500000000000000000000000001465704072200212325ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/analysis/report/report.go000066400000000000000000000150161465704072200230770ustar00rootroot00000000000000package report import ( "bytes" "fmt" "go/ast" "go/format" "go/token" "go/version" "path/filepath" "strconv" "strings" "honnef.co/go/tools/analysis/code" "honnef.co/go/tools/analysis/facts/generated" "honnef.co/go/tools/go/ast/astutil" "golang.org/x/tools/go/analysis" ) type Options struct { ShortRange bool FilterGenerated bool Fixes []analysis.SuggestedFix Related []analysis.RelatedInformation MinimumLanguageVersion string MaximumLanguageVersion string MinimumStdlibVersion string MaximumStdlibVersion string } type Option func(*Options) func ShortRange() Option { return func(opts *Options) { opts.ShortRange = true } } func FilterGenerated() Option { return func(opts *Options) { opts.FilterGenerated = true } } func Fixes(fixes ...analysis.SuggestedFix) Option { return func(opts *Options) { opts.Fixes = append(opts.Fixes, fixes...) } } func Related(node Positioner, message string) Option { return func(opts *Options) { pos, end, ok := getRange(node, opts.ShortRange) if !ok { return } r := analysis.RelatedInformation{ Pos: pos, End: end, Message: message, } opts.Related = append(opts.Related, r) } } func MinimumLanguageVersion(vers string) Option { return func(opts *Options) { opts.MinimumLanguageVersion = vers } } func MaximumLanguageVersion(vers string) Option { return func(opts *Options) { opts.MinimumLanguageVersion = vers } } func MinimumStdlibVersion(vers string) Option { return func(opts *Options) { opts.MinimumStdlibVersion = vers } } func MaximumStdlibVersion(vers string) Option { return func(opts *Options) { opts.MaximumStdlibVersion = vers } } type Positioner interface { Pos() token.Pos } type fullPositioner interface { Pos() token.Pos End() token.Pos } type sourcer interface { Source() ast.Node } // shortRange returns the position and end of the main component of an // AST node. For nodes that have no body, the short range is identical // to the node's Pos and End. For nodes that do have a body, the short // range excludes the body. func shortRange(node ast.Node) (pos, end token.Pos) { switch node := node.(type) { case *ast.File: return node.Pos(), node.Name.End() case *ast.CaseClause: return node.Pos(), node.Colon + 1 case *ast.CommClause: return node.Pos(), node.Colon + 1 case *ast.DeferStmt: return node.Pos(), node.Defer + token.Pos(len("defer")) case *ast.ExprStmt: return shortRange(node.X) case *ast.ForStmt: if node.Post != nil { return node.For, node.Post.End() } else if node.Cond != nil { return node.For, node.Cond.End() } else if node.Init != nil { // +1 to catch the semicolon, for gofmt'ed code return node.Pos(), node.Init.End() + 1 } else { return node.Pos(), node.For + token.Pos(len("for")) } case *ast.FuncDecl: return node.Pos(), node.Type.End() case *ast.FuncLit: return node.Pos(), node.Type.End() case *ast.GoStmt: if _, ok := astutil.Unparen(node.Call.Fun).(*ast.FuncLit); ok { return node.Pos(), node.Go + token.Pos(len("go")) } else { return node.Pos(), node.End() } case *ast.IfStmt: return node.Pos(), node.Cond.End() case *ast.RangeStmt: return node.Pos(), node.X.End() case *ast.SelectStmt: return node.Pos(), node.Pos() + token.Pos(len("select")) case *ast.SwitchStmt: if node.Tag != nil { return node.Pos(), node.Tag.End() } else if node.Init != nil { // +1 to catch the semicolon, for gofmt'ed code return node.Pos(), node.Init.End() + 1 } else { return node.Pos(), node.Pos() + token.Pos(len("switch")) } case *ast.TypeSwitchStmt: return node.Pos(), node.Assign.End() default: return node.Pos(), node.End() } } func HasRange(node Positioner) bool { // we don't know if getRange will be called with shortRange set to // true, so make sure that both work. _, _, ok := getRange(node, false) if !ok { return false } _, _, ok = getRange(node, true) return ok } func getRange(node Positioner, short bool) (pos, end token.Pos, ok bool) { switch n := node.(type) { case sourcer: s := n.Source() if s == nil { return 0, 0, false } if short { p, e := shortRange(s) return p, e, true } return s.Pos(), s.End(), true case fullPositioner: if short { p, e := shortRange(n) return p, e, true } return n.Pos(), n.End(), true default: return n.Pos(), token.NoPos, true } } func Report(pass *analysis.Pass, node Positioner, message string, opts ...Option) { cfg := &Options{} for _, opt := range opts { opt(cfg) } langVersion := code.LanguageVersion(pass, node) stdlibVersion := code.StdlibVersion(pass, node) if n := cfg.MaximumLanguageVersion; n != "" && version.Compare(n, langVersion) == -1 { return } if n := cfg.MaximumStdlibVersion; n != "" && version.Compare(n, stdlibVersion) == -1 { return } if n := cfg.MinimumLanguageVersion; n != "" && version.Compare(n, langVersion) == 1 { return } if n := cfg.MinimumStdlibVersion; n != "" && version.Compare(n, stdlibVersion) == 1 { return } file := DisplayPosition(pass.Fset, node.Pos()).Filename if cfg.FilterGenerated { m := pass.ResultOf[generated.Analyzer].(map[string]generated.Generator) if _, ok := m[file]; ok { return } } pos, end, ok := getRange(node, cfg.ShortRange) if !ok { panic(fmt.Sprintf("no valid position for reporting node %v", node)) } d := analysis.Diagnostic{ Pos: pos, End: end, Message: message, SuggestedFixes: cfg.Fixes, Related: cfg.Related, } pass.Report(d) } func Render(pass *analysis.Pass, x interface{}) string { var buf bytes.Buffer if err := format.Node(&buf, pass.Fset, x); err != nil { panic(err) } return buf.String() } func RenderArgs(pass *analysis.Pass, args []ast.Expr) string { var ss []string for _, arg := range args { ss = append(ss, Render(pass, arg)) } return strings.Join(ss, ", ") } func DisplayPosition(fset *token.FileSet, p token.Pos) token.Position { if p == token.NoPos { return token.Position{} } // Only use the adjusted position if it points to another Go file. // This means we'll point to the original file for cgo files, but // we won't point to a YACC grammar file. pos := fset.PositionFor(p, false) adjPos := fset.PositionFor(p, true) if filepath.Ext(adjPos.Filename) == ".go" { return adjPos } return pos } func Ordinal(n int) string { suffix := "th" if n < 10 || n > 20 { switch n % 10 { case 0: suffix = "th" case 1: suffix = "st" case 2: suffix = "nd" case 3: suffix = "rd" default: suffix = "th" } } return strconv.Itoa(n) + suffix } golang-honnef-go-tools-2024.1/analysis/report/report_test.go000066400000000000000000000012401465704072200241300ustar00rootroot00000000000000package report import "testing" func TestOrdinal(t *testing.T) { tests := []struct { num int want string }{ {0, "0th"}, {1, "1st"}, {2, "2nd"}, {3, "3rd"}, {4, "4th"}, {5, "5th"}, {6, "6th"}, {7, "7th"}, {8, "8th"}, {9, "9th"}, {10, "10th"}, {11, "11th"}, {12, "12th"}, {13, "13th"}, {14, "14th"}, {15, "15th"}, {16, "16th"}, {17, "17th"}, {18, "18th"}, {19, "19th"}, {20, "20th"}, {21, "21st"}, {22, "22nd"}, {23, "23rd"}, {24, "24th"}, {25, "25th"}, {26, "26th"}, {27, "27th"}, {28, "28th"}, {29, "29th"}, } for _, tt := range tests { if got := Ordinal(tt.num); got != tt.want { t.Errorf("Ordinal(%d) = %s, want %s", tt.num, got, tt.want) } } } golang-honnef-go-tools-2024.1/cmd/000077500000000000000000000000001465704072200166375ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/cmd/staticcheck/000077500000000000000000000000001465704072200211245ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/cmd/staticcheck/README.md000066400000000000000000000006351465704072200224070ustar00rootroot00000000000000# staticcheck _staticcheck_ offers extensive analysis of Go code, covering a myriad of categories. It will detect bugs, suggest code simplifications, point out dead code, and more. ## Installation See [the main README](https://github.com/dominikh/go-tools#installation) for installation instructions. ## Documentation Detailed documentation can be found on [staticcheck.dev](https://staticcheck.dev/docs/). golang-honnef-go-tools-2024.1/cmd/staticcheck/staticcheck.go000066400000000000000000000020151465704072200237360ustar00rootroot00000000000000// staticcheck analyses Go code and makes it better. package main import ( "log" "os" "honnef.co/go/tools/lintcmd" "honnef.co/go/tools/lintcmd/version" "honnef.co/go/tools/quickfix" "honnef.co/go/tools/simple" "honnef.co/go/tools/staticcheck" "honnef.co/go/tools/stylecheck" "honnef.co/go/tools/unused" ) func main() { cmd := lintcmd.NewCommand("staticcheck") cmd.SetVersion(version.Version, version.MachineVersion) fs := cmd.FlagSet() debug := fs.String("debug.unused-graph", "", "Write unused's object graph to `file`") qf := fs.Bool("debug.run-quickfix-analyzers", false, "Run quickfix analyzers") cmd.ParseFlags(os.Args[1:]) cmd.AddAnalyzers(simple.Analyzers...) cmd.AddAnalyzers(staticcheck.Analyzers...) cmd.AddAnalyzers(stylecheck.Analyzers...) cmd.AddAnalyzers(unused.Analyzer) if *qf { cmd.AddAnalyzers(quickfix.Analyzers...) } if *debug != "" { f, err := os.OpenFile(*debug, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666) if err != nil { log.Fatal(err) } unused.Debug = f } cmd.Run() } golang-honnef-go-tools-2024.1/cmd/structlayout-optimize/000077500000000000000000000000001465704072200232575ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/cmd/structlayout-optimize/main.go000066400000000000000000000075471465704072200245470ustar00rootroot00000000000000// structlayout-optimize reorders struct fields to minimize the amount // of padding. package main import ( "encoding/json" "flag" "fmt" "log" "os" "sort" "strings" "honnef.co/go/tools/lintcmd/version" st "honnef.co/go/tools/structlayout" ) var ( fJSON bool fRecurse bool fVersion bool ) func init() { flag.BoolVar(&fJSON, "json", false, "Format data as JSON") flag.BoolVar(&fRecurse, "r", false, "Break up structs and reorder their fields freely") flag.BoolVar(&fVersion, "version", false, "Print version and exit") } func main() { log.SetFlags(0) flag.Parse() if fVersion { version.Print(version.Version, version.MachineVersion) os.Exit(0) } var in []st.Field if err := json.NewDecoder(os.Stdin).Decode(&in); err != nil { log.Fatal(err) } if len(in) == 0 { return } if !fRecurse { in = combine(in) } var fields []st.Field for _, field := range in { if field.IsPadding { continue } fields = append(fields, field) } optimize(fields) fields = pad(fields) if fJSON { json.NewEncoder(os.Stdout).Encode(fields) } else { for _, field := range fields { fmt.Println(field) } } } func combine(fields []st.Field) []st.Field { new := st.Field{} cur := "" var out []st.Field wasPad := true for _, field := range fields { var prefix string if field.IsPadding { wasPad = true continue } p := strings.Split(field.Name, ".") prefix = strings.Join(p[:2], ".") if field.Align > new.Align { new.Align = field.Align } if !wasPad { new.End = field.Start new.Size = new.End - new.Start } if prefix != cur { if cur != "" { out = append(out, new) } cur = prefix new = field new.Name = prefix } else { new.Type = "struct" } wasPad = false } new.Size = new.End - new.Start out = append(out, new) return out } func optimize(fields []st.Field) { sort.Sort(&byAlignAndSize{fields}) } func pad(fields []st.Field) []st.Field { if len(fields) == 0 { return nil } var out []st.Field pos := int64(0) offsets := offsetsof(fields) alignment := int64(1) for i, field := range fields { if field.Align > alignment { alignment = field.Align } if offsets[i] > pos { padding := offsets[i] - pos out = append(out, st.Field{ IsPadding: true, Start: pos, End: pos + padding, Size: padding, }) pos += padding } field.Start = pos field.End = pos + field.Size out = append(out, field) pos += field.Size } sz := size(out) pad := align(sz, alignment) - sz if pad > 0 { field := out[len(out)-1] out = append(out, st.Field{ IsPadding: true, Start: field.End, End: field.End + pad, Size: pad, }) } return out } func size(fields []st.Field) int64 { n := int64(0) for _, field := range fields { n += field.Size } return n } type byAlignAndSize struct { fields []st.Field } func (s *byAlignAndSize) Len() int { return len(s.fields) } func (s *byAlignAndSize) Swap(i, j int) { s.fields[i], s.fields[j] = s.fields[j], s.fields[i] } func (s *byAlignAndSize) Less(i, j int) bool { // Place zero sized objects before non-zero sized objects. if s.fields[i].Size == 0 && s.fields[j].Size != 0 { return true } if s.fields[j].Size == 0 && s.fields[i].Size != 0 { return false } // Next, place more tightly aligned objects before less tightly aligned objects. if s.fields[i].Align != s.fields[j].Align { return s.fields[i].Align > s.fields[j].Align } // Lastly, order by size. if s.fields[i].Size != s.fields[j].Size { return s.fields[i].Size > s.fields[j].Size } return false } func offsetsof(fields []st.Field) []int64 { offsets := make([]int64, len(fields)) var o int64 for i, f := range fields { a := f.Align o = align(o, a) offsets[i] = o o += f.Size } return offsets } // align returns the smallest y >= x such that y % a == 0. func align(x, a int64) int64 { y := x + a - 1 return y - y%a } golang-honnef-go-tools-2024.1/cmd/structlayout-pretty/000077500000000000000000000000001465704072200227465ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/cmd/structlayout-pretty/main.go000066400000000000000000000030761465704072200242270ustar00rootroot00000000000000// structlayout-pretty formats the output of structlayout with ASCII // art. package main import ( "encoding/json" "flag" "fmt" "log" "os" "strings" "honnef.co/go/tools/lintcmd/version" st "honnef.co/go/tools/structlayout" ) var ( fVerbose bool fVersion bool ) func init() { flag.BoolVar(&fVerbose, "v", false, "Do not compact consecutive bytes of fields") flag.BoolVar(&fVersion, "version", false, "Print version and exit") } func main() { log.SetFlags(0) flag.Parse() if fVersion { version.Print(version.Version, version.MachineVersion) os.Exit(0) } var fields []st.Field if err := json.NewDecoder(os.Stdin).Decode(&fields); err != nil { log.Fatal(err) } if len(fields) == 0 { return } max := fields[len(fields)-1].End maxLength := len(fmt.Sprintf("%d", max)) padding := strings.Repeat(" ", maxLength+2) format := fmt.Sprintf(" %%%dd ", maxLength) pos := int64(0) fmt.Println(padding + "+--------+") for _, field := range fields { name := field.Name + " " + field.Type if field.IsPadding { name = "padding" } fmt.Printf(format+"| | <- %s (size %d, align %d)\n", pos, name, field.Size, field.Align) fmt.Println(padding + "+--------+") if fVerbose { for i := int64(0); i < field.Size-1; i++ { fmt.Printf(format+"| |\n", pos+i+1) fmt.Println(padding + "+--------+") } } else { if field.Size > 2 { fmt.Println(padding + "-........-") fmt.Println(padding + "+--------+") fmt.Printf(format+"| |\n", pos+field.Size-1) fmt.Println(padding + "+--------+") } } pos += field.Size } } golang-honnef-go-tools-2024.1/cmd/structlayout/000077500000000000000000000000001465704072200214215ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/cmd/structlayout/README.md000066400000000000000000000054271465704072200227100ustar00rootroot00000000000000# structlayout The _structlayout_ utility prints the layout of a struct – that is the byte offset and size of each field, respecting alignment/padding. The information is printed in human-readable form by default, but can be emitted as JSON with the `-json` flag. This makes it easy to consume this information in other tools. A utility called _structlayout-pretty_ takes this JSON and prints an ASCII graphic representing the memory layout. _structlayout-optimize_ is another tool. Inspired by [maligned](https://github.com/mdempsky/maligned), it reads _structlayout_ JSON on stdin and reorders fields to minimize the amount of padding. The tool can itself emit JSON and feed into e.g. _structlayout-pretty_. _structlayout-svg_ is a third-party tool that, similarly to _structlayout-pretty_, visualises struct layouts. It does so by generating a fancy-looking SVG graphic. You can install it via ``` go get github.com/ajstarks/svgo/structlayout-svg ``` ## Installation See [the main README](https://github.com/dominikh/go-tools#installation) for installation instructions. ## Examples ``` $ structlayout bufio Reader Reader.buf []byte: 0-24 (24 bytes) Reader.rd io.Reader: 24-40 (16 bytes) Reader.r int: 40-48 (8 bytes) Reader.w int: 48-56 (8 bytes) Reader.err error: 56-72 (16 bytes) Reader.lastByte int: 72-80 (8 bytes) Reader.lastRuneSize int: 80-88 (8 bytes) ``` ``` $ structlayout -json bufio Reader | jq . [ { "name": "Reader.buf", "type": "[]byte", "start": 0, "end": 24, "size": 24, "is_padding": false }, { "name": "Reader.rd", "type": "io.Reader", "start": 24, "end": 40, "size": 16, "is_padding": false }, { "name": "Reader.r", "type": "int", "start": 40, "end": 48, "size": 8, "is_padding": false }, ... ``` ``` $ structlayout -json bufio Reader | structlayout-pretty +--------+ 0 | | <- Reader.buf []byte +--------+ -........- +--------+ 23 | | +--------+ 24 | | <- Reader.rd io.Reader +--------+ -........- +--------+ 39 | | +--------+ 40 | | <- Reader.r int +--------+ -........- +--------+ 47 | | +--------+ 48 | | <- Reader.w int +--------+ -........- +--------+ 55 | | +--------+ 56 | | <- Reader.err error +--------+ -........- +--------+ 71 | | +--------+ 72 | | <- Reader.lastByte int +--------+ -........- +--------+ 79 | | +--------+ 80 | | <- Reader.lastRuneSize int +--------+ -........- +--------+ 87 | | +--------+ ``` ``` $ structlayout -json bytes Buffer | structlayout-svg -t "bytes.Buffer" > /tmp/struct.svg ``` ![memory layout of bytes.Buffer](/images/screenshots/struct.png) golang-honnef-go-tools-2024.1/cmd/structlayout/main.go000066400000000000000000000056101465704072200226760ustar00rootroot00000000000000// structlayout displays the layout (field sizes and padding) of structs. package main import ( "encoding/json" "flag" "fmt" "go/build" "go/types" "log" "os" "honnef.co/go/tools/go/gcsizes" "honnef.co/go/tools/lintcmd/version" st "honnef.co/go/tools/structlayout" "golang.org/x/tools/go/packages" ) var ( fJSON bool fVersion bool ) func init() { flag.BoolVar(&fJSON, "json", false, "Format data as JSON") flag.BoolVar(&fVersion, "version", false, "Print version and exit") } func main() { log.SetFlags(0) flag.Parse() if fVersion { version.Print(version.Version, version.MachineVersion) os.Exit(0) } if len(flag.Args()) != 2 { flag.Usage() os.Exit(1) } cfg := &packages.Config{ Mode: packages.NeedImports | packages.NeedExportFile | packages.NeedTypes | packages.NeedSyntax, Tests: true, } pkgs, err := packages.Load(cfg, flag.Args()[0]) if err != nil { log.Fatal(err) } for _, pkg := range pkgs { typName := flag.Args()[1] var typ types.Type obj := pkg.Types.Scope().Lookup(typName) if obj == nil { continue } typ = obj.Type() st, ok := typ.Underlying().(*types.Struct) if !ok { log.Fatal("identifier is not a struct type") } fields := sizes(st, types.Unalias(typ).(*types.Named).Obj().Name(), 0, nil) if fJSON { emitJSON(fields) } else { emitText(fields) } return } log.Fatal("couldn't find type") } func emitJSON(fields []st.Field) { if fields == nil { fields = []st.Field{} } json.NewEncoder(os.Stdout).Encode(fields) } func emitText(fields []st.Field) { for _, field := range fields { fmt.Println(field) } } func sizes(typ *types.Struct, prefix string, base int64, out []st.Field) []st.Field { s := gcsizes.ForArch(build.Default.GOARCH) n := typ.NumFields() var fields []*types.Var for i := 0; i < n; i++ { fields = append(fields, typ.Field(i)) } offsets := s.Offsetsof(fields) for i := range offsets { offsets[i] += base } pos := base for i, field := range fields { if offsets[i] > pos { padding := offsets[i] - pos out = append(out, st.Field{ IsPadding: true, Start: pos, End: pos + padding, Size: padding, }) pos += padding } size := s.Sizeof(field.Type()) if typ2, ok := field.Type().Underlying().(*types.Struct); ok && typ2.NumFields() != 0 { out = sizes(typ2, prefix+"."+field.Name(), pos, out) } else { out = append(out, st.Field{ Name: prefix + "." + field.Name(), Type: field.Type().String(), Start: offsets[i], End: offsets[i] + size, Size: size, Align: s.Alignof(field.Type()), }) } pos += size } if len(out) == 0 { return out } field := &out[len(out)-1] if field.Size == 0 { field.Size = 1 field.End++ } pad := s.Sizeof(typ) - field.End if pad > 0 { out = append(out, st.Field{ IsPadding: true, Start: field.End, End: field.End + pad, Size: pad, }) } return out } golang-honnef-go-tools-2024.1/config/000077500000000000000000000000001465704072200173415ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/config/config.go000066400000000000000000000150631465704072200211420ustar00rootroot00000000000000package config import ( "bytes" "fmt" "go/ast" "go/token" "os" "path/filepath" "reflect" "strings" "github.com/BurntSushi/toml" "golang.org/x/tools/go/analysis" ) // Dir looks at a list of absolute file names, which should make up a // single package, and returns the path of the directory that may // contain a staticcheck.conf file. It returns the empty string if no // such directory could be determined, for example because all files // were located in Go's build cache. func Dir(files []string) string { if len(files) == 0 { return "" } cache, err := os.UserCacheDir() if err != nil { cache = "" } var path string for _, p := range files { // FIXME(dh): using strings.HasPrefix isn't technically // correct, but it should be good enough for now. if cache != "" && strings.HasPrefix(p, cache) { // File in the build cache of the standard Go build system continue } path = p break } if path == "" { // The package only consists of generated files. return "" } dir := filepath.Dir(path) return dir } func dirAST(files []*ast.File, fset *token.FileSet) string { names := make([]string, len(files)) for i, f := range files { names[i] = fset.PositionFor(f.Pos(), true).Filename } return Dir(names) } var Analyzer = &analysis.Analyzer{ Name: "config", Doc: "loads configuration for the current package tree", Run: func(pass *analysis.Pass) (interface{}, error) { dir := dirAST(pass.Files, pass.Fset) if dir == "" { cfg := DefaultConfig return &cfg, nil } cfg, err := Load(dir) if err != nil { return nil, fmt.Errorf("error loading staticcheck.conf: %s", err) } return &cfg, nil }, RunDespiteErrors: true, ResultType: reflect.TypeOf((*Config)(nil)), } func For(pass *analysis.Pass) *Config { return pass.ResultOf[Analyzer].(*Config) } func mergeLists(a, b []string) []string { out := make([]string, 0, len(a)+len(b)) for _, el := range b { if el == "inherit" { out = append(out, a...) } else { out = append(out, el) } } return out } func normalizeList(list []string) []string { if len(list) > 1 { nlist := make([]string, 0, len(list)) nlist = append(nlist, list[0]) for i, el := range list[1:] { if el != list[i] { nlist = append(nlist, el) } } list = nlist } for _, el := range list { if el == "inherit" { // This should never happen, because the default config // should not use "inherit" panic(`unresolved "inherit"`) } } return list } func (cfg Config) Merge(ocfg Config) Config { if ocfg.Checks != nil { cfg.Checks = mergeLists(cfg.Checks, ocfg.Checks) } if ocfg.Initialisms != nil { cfg.Initialisms = mergeLists(cfg.Initialisms, ocfg.Initialisms) } if ocfg.DotImportWhitelist != nil { cfg.DotImportWhitelist = mergeLists(cfg.DotImportWhitelist, ocfg.DotImportWhitelist) } if ocfg.HTTPStatusCodeWhitelist != nil { cfg.HTTPStatusCodeWhitelist = mergeLists(cfg.HTTPStatusCodeWhitelist, ocfg.HTTPStatusCodeWhitelist) } return cfg } type Config struct { // TODO(dh): this implementation makes it impossible for external // clients to add their own checkers with configuration. At the // moment, we don't really care about that; we don't encourage // that people use this package. In the future, we may. The // obvious solution would be using map[string]interface{}, but // that's obviously subpar. Checks []string `toml:"checks"` Initialisms []string `toml:"initialisms"` DotImportWhitelist []string `toml:"dot_import_whitelist"` HTTPStatusCodeWhitelist []string `toml:"http_status_code_whitelist"` } func (c Config) String() string { buf := &bytes.Buffer{} fmt.Fprintf(buf, "Checks: %#v\n", c.Checks) fmt.Fprintf(buf, "Initialisms: %#v\n", c.Initialisms) fmt.Fprintf(buf, "DotImportWhitelist: %#v\n", c.DotImportWhitelist) fmt.Fprintf(buf, "HTTPStatusCodeWhitelist: %#v", c.HTTPStatusCodeWhitelist) return buf.String() } // DefaultConfig is the default configuration. // Its initial value describes the majority of the default configuration, // but the Checks field can be updated at runtime based on the analyzers being used, to disable non-default checks. // For cmd/staticcheck, this is handled by (*lintcmd.Command).Run. // // Note that DefaultConfig shouldn't be modified while analyzers are executing. var DefaultConfig = Config{ Checks: []string{"all"}, Initialisms: []string{ "ACL", "API", "ASCII", "CPU", "CSS", "DNS", "EOF", "GUID", "HTML", "HTTP", "HTTPS", "ID", "IP", "JSON", "QPS", "RAM", "RPC", "SLA", "SMTP", "SQL", "SSH", "TCP", "TLS", "TTL", "UDP", "UI", "GID", "UID", "UUID", "URI", "URL", "UTF8", "VM", "XML", "XMPP", "XSRF", "XSS", "SIP", "RTP", "AMQP", "DB", "TS", }, DotImportWhitelist: []string{ "github.com/mmcloughlin/avo/build", "github.com/mmcloughlin/avo/operand", "github.com/mmcloughlin/avo/reg", }, HTTPStatusCodeWhitelist: []string{"200", "400", "404", "500"}, } const ConfigName = "staticcheck.conf" type ParseError struct { Filename string toml.ParseError } func parseConfigs(dir string) ([]Config, error) { var out []Config // TODO(dh): consider stopping at the GOPATH/module boundary for dir != "" { f, err := os.Open(filepath.Join(dir, ConfigName)) if os.IsNotExist(err) { ndir := filepath.Dir(dir) if ndir == dir { break } dir = ndir continue } if err != nil { return nil, err } var cfg Config _, err = toml.NewDecoder(f).Decode(&cfg) f.Close() if err != nil { if err, ok := err.(toml.ParseError); ok { return nil, ParseError{ Filename: filepath.Join(dir, ConfigName), ParseError: err, } } return nil, err } out = append(out, cfg) ndir := filepath.Dir(dir) if ndir == dir { break } dir = ndir } out = append(out, DefaultConfig) if len(out) < 2 { return out, nil } for i := 0; i < len(out)/2; i++ { out[i], out[len(out)-1-i] = out[len(out)-1-i], out[i] } return out, nil } func mergeConfigs(confs []Config) Config { if len(confs) == 0 { // This shouldn't happen because we always have at least a // default config. panic("trying to merge zero configs") } if len(confs) == 1 { return confs[0] } conf := confs[0] for _, oconf := range confs[1:] { conf = conf.Merge(oconf) } return conf } func Load(dir string) (Config, error) { confs, err := parseConfigs(dir) if err != nil { return Config{}, err } conf := mergeConfigs(confs) conf.Checks = normalizeList(conf.Checks) conf.Initialisms = normalizeList(conf.Initialisms) conf.DotImportWhitelist = normalizeList(conf.DotImportWhitelist) conf.HTTPStatusCodeWhitelist = normalizeList(conf.HTTPStatusCodeWhitelist) return conf, nil } golang-honnef-go-tools-2024.1/config/example.conf000066400000000000000000000011711465704072200216430ustar00rootroot00000000000000checks = ["all", "-SA9003", "-ST1000", "-ST1003", "-ST1016", "-ST1020", "-ST1021", "-ST1022", "-ST1023"] initialisms = ["ACL", "API", "ASCII", "CPU", "CSS", "DNS", "EOF", "GUID", "HTML", "HTTP", "HTTPS", "ID", "IP", "JSON", "QPS", "RAM", "RPC", "SLA", "SMTP", "SQL", "SSH", "TCP", "TLS", "TTL", "UDP", "UI", "GID", "UID", "UUID", "URI", "URL", "UTF8", "VM", "XML", "XMPP", "XSRF", "XSS", "SIP", "RTP", "AMQP", "DB", "TS"] dot_import_whitelist = [ "github.com/mmcloughlin/avo/build", "github.com/mmcloughlin/avo/operand", "github.com/mmcloughlin/avo/reg", ] http_status_code_whitelist = ["200", "400", "404", "500"] golang-honnef-go-tools-2024.1/debug/000077500000000000000000000000001465704072200171625ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/debug/debug.go000066400000000000000000000034151465704072200206020ustar00rootroot00000000000000// Package debug contains helpers for debugging static analyses. package debug import ( "bytes" "go/ast" "go/format" "go/importer" "go/parser" "go/token" "go/types" "sync" ) // TypeCheck parses and type-checks a single-file Go package from a string. // The package must not have any imports. func TypeCheck(src string) (*ast.File, *types.Package, *types.Info, error) { fset := token.NewFileSet() f, err := parser.ParseFile(fset, "foo.go", src, parser.ParseComments|parser.SkipObjectResolution) if err != nil { return nil, nil, nil, err } pkg := types.NewPackage("foo", f.Name.Name) info := &types.Info{ Types: map[ast.Expr]types.TypeAndValue{}, Defs: map[*ast.Ident]types.Object{}, Uses: map[*ast.Ident]types.Object{}, Implicits: map[ast.Node]types.Object{}, Selections: map[*ast.SelectorExpr]*types.Selection{}, Scopes: map[ast.Node]*types.Scope{}, InitOrder: []*types.Initializer{}, Instances: map[*ast.Ident]types.Instance{}, } tcfg := &types.Config{ Importer: importer.Default(), } if err := types.NewChecker(tcfg, fset, pkg, info).Files([]*ast.File{f}); err != nil { return nil, nil, nil, err } return f, pkg, info, nil } func FormatNode(node ast.Node) string { var buf bytes.Buffer fset := token.NewFileSet() format.Node(&buf, fset, node) return buf.String() } var aliasesDefaultOnce sync.Once var gotypesaliasDefault bool func AliasesEnabled() bool { // Dynamically check if Aliases will be produced from go/types. aliasesDefaultOnce.Do(func() { fset := token.NewFileSet() f, _ := parser.ParseFile(fset, "a.go", "package p; type A = int", 0) pkg, _ := new(types.Config).Check("p", fset, []*ast.File{f}, nil) _, gotypesaliasDefault = pkg.Scope().Lookup("A").Type().(*types.Alias) }) return gotypesaliasDefault } golang-honnef-go-tools-2024.1/dist/000077500000000000000000000000001465704072200170375ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/dist/build.sh000077500000000000000000000030331465704072200204740ustar00rootroot00000000000000#!/bin/sh -e build() { ROOT="$GOPATH/src/honnef.co/go/tools" os="$1" arch="$2" echo "Building GOOS=$os GOARCH=$arch..." exe="staticcheck" if [ $os = "windows" ]; then exe="${exe}.exe" fi target="staticcheck_${os}_${arch}" arm="" case "$arch" in armv5l) arm=5 arch=arm ;; armv6l) arm=6 arch=arm ;; armv7l) arm=7 arch=arm ;; arm64) arch=arm64 ;; esac mkdir "$d/staticcheck" cp "$ROOT/LICENSE" "$ROOT/LICENSE-THIRD-PARTY" "$d/staticcheck" CGO_ENABLED=0 GOOS=$os GOARCH=$arch GOARM=$arm GO111MODULE=on go build -trimpath -o "$d/staticcheck/$exe" honnef.co/go/tools/cmd/staticcheck ( cd "$d" tar -czf "$target.tar.gz" staticcheck sha256sum "$target.tar.gz" > "$target.tar.gz.sha256" ) rm -rf "$d/staticcheck" } rev="$1" if [ -z "$rev" ]; then echo "Usage: $0 " exit 1 fi mkdir "$rev" d=$(realpath "$rev") wrk=$(mktemp -d) trap "{ rm -rf \"$wrk\"; }" EXIT cd "$wrk" go mod init foo GO111MODULE=on go get -d honnef.co/go/tools/cmd/staticcheck@"$rev" SYSTEMS=(windows linux freebsd) ARCHS=(amd64 386) for os in ${SYSTEMS[@]}; do for arch in ${ARCHS[@]}; do build "$os" "$arch" done done build "darwin" "amd64" build "darwin" "arm64" for arch in armv5l armv6l armv7l arm64; do build "linux" "$arch" done ( cd "$d" sha256sum -c --strict *.sha256 ) golang-honnef-go-tools-2024.1/doc/000077500000000000000000000000001465704072200166415ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/doc/articles/000077500000000000000000000000001465704072200204475ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/doc/articles/customizing_staticcheck.html000066400000000000000000000003131465704072200262520ustar00rootroot00000000000000- how to customize staticcheck - tools serve humans - tools should assist workflows - don't let tools bully you - exit status - which checks run - ignoring findings - output format - go version - tests golang-honnef-go-tools-2024.1/doc/run.html000066400000000000000000000027331465704072200203400ustar00rootroot00000000000000

Running Staticcheck

Checking packages

The staticcheck command works much like go build or go vet do. It supports all of the same package patterns. For example, staticcheck . will check the current package, and staticcheck ./... will check all packages. For more details on specifying packages to check, see go help packages

Explaining checks

You can use staticcheck -explain <check> to get a helpful description of a check.

Every diagnostic that staticcheck reports is annotated with the identifier of the specific check that found the issue. For example, in 

foo.go:1248:4: unnecessary use of fmt.Sprintf (S1039)

the check's identifier is S1039. Running staticcheck -explain S1039 will output the following: 

Unnecessary use of fmt.Sprint

Calling fmt.Sprint with a single string argument is unnecessary and identical to using the string directly.

Available since
    2020.1

Online documentation
    https://staticcheck.dev/docs/checks#S1039

The output includes a one-line summary, one or more paragraphs of helpful text, the first version of Staticcheck that the check appeared in, and a link to online documentation, which contains the same information as the output of staticcheck -explain.

golang-honnef-go-tools-2024.1/generate.go000066400000000000000000000041121465704072200202130ustar00rootroot00000000000000//go:build ignore package main import ( "bytes" "go/format" "log" "os" "path/filepath" "regexp" "text/template" ) var tmpl = ` {{define "analyzers"}} // Code generated by generate.go. DO NOT EDIT. package {{.dir}} import ( "honnef.co/go/tools/analysis/lint" {{- range $check := .checks}} "honnef.co/go/tools/{{$.dir}}/{{$check}}" {{- end}} ) var Analyzers = []*lint.Analyzer{ {{- range $check := .checks}} {{$check}}.SCAnalyzer, {{- end}} } {{end}} {{define "tests"}} // Code generated by generate.go. DO NOT EDIT. package {{.check}} import ( "testing" "honnef.co/go/tools/analysis/lint/testutil" ) func TestTestdata(t *testing.T) { testutil.Run(t, SCAnalyzer) } {{end}} ` func main() { log.SetFlags(0) dir, err := os.Getwd() if err != nil { log.Fatalln("couldn't determine current directory:", err) } dir = filepath.Base(dir) var t template.Template if _, err = t.Parse(tmpl); err != nil { log.Fatalln("couldn't parse templates:", err) } dirs, err := filepath.Glob("*") if err != nil { log.Fatalln("couldn't enumerate checks:", err) } checkRe := regexp.MustCompile(`^[a-z]+\d{4}$`) out := dirs[:0] for _, dir := range dirs { if checkRe.MatchString(dir) { out = append(out, dir) } } dirs = out buf := bytes.NewBuffer(nil) if err := t.ExecuteTemplate(buf, "analyzers", map[string]any{"checks": dirs, "dir": dir}); err != nil { log.Fatalln("couldn't generate analysis.go:", err) } b, err := format.Source(buf.Bytes()) if err != nil { log.Fatalln("couldn't gofmt analysis.go:", err) } if err := os.WriteFile("analysis.go", b, 0666); err != nil { log.Fatalln("couldn't write analysis.go:", err) } for _, dir := range dirs { buf.Reset() dst := filepath.Join(dir, dir+"_test.go") if err := t.ExecuteTemplate(buf, "tests", map[string]any{"check": dir}); err != nil { log.Fatalf("couldn't generate %s: %s", dst, err) } b, err := format.Source(buf.Bytes()) if err != nil { log.Fatalf("couldn't gofmt %s: %s", dst, err) } if err := os.WriteFile(dst, b, 0666); err != nil { log.Fatalf("couldn't write %s: %s", dst, err) } } } golang-honnef-go-tools-2024.1/go.mod000066400000000000000000000006251465704072200172050ustar00rootroot00000000000000module honnef.co/go/tools go 1.22.1 require ( github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa golang.org/x/exp/typeparams v0.0.0-20231108232855-2478ac86f678 golang.org/x/sys v0.20.0 golang.org/x/tools v0.21.1-0.20240531212143-b6235391adb3 ) require ( golang.org/x/mod v0.17.0 // indirect golang.org/x/sync v0.7.0 // indirect ) golang-honnef-go-tools-2024.1/go.sum000066400000000000000000000024771465704072200172410ustar00rootroot00000000000000github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c h1:pxW6RcqyfI9/kWtOwnv/G+AzdKuy2ZrqINhenH4HyNs= github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho= golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ= golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE= golang.org/x/exp/typeparams v0.0.0-20231108232855-2478ac86f678 h1:1P7xPZEwZMoBoz0Yze5Nx2/4pxj6nw9ZqHWXqP0iRgQ= golang.org/x/exp/typeparams v0.0.0-20231108232855-2478ac86f678/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk= golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA= golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M= golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y= golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/tools v0.21.1-0.20240531212143-b6235391adb3 h1:SHq4Rl+B7WvyM4XODon1LXtP7gcG49+7Jubt1gWWswY= golang.org/x/tools v0.21.1-0.20240531212143-b6235391adb3/go.mod h1:bqv7PJ/TtlrzgJKhOAGdDUkUltQapRik/UEHubLVBWo= golang-honnef-go-tools-2024.1/go/000077500000000000000000000000001465704072200165015ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/go/ast/000077500000000000000000000000001465704072200172705ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/go/ast/astutil/000077500000000000000000000000001465704072200207555ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/go/ast/astutil/upstream.go000066400000000000000000000006561465704072200231530ustar00rootroot00000000000000package astutil import ( "go/ast" "go/token" _ "unsafe" "golang.org/x/tools/go/ast/astutil" ) type Cursor = astutil.Cursor type ApplyFunc = astutil.ApplyFunc func Apply(root ast.Node, pre, post ApplyFunc) (result ast.Node) { return astutil.Apply(root, pre, post) } func PathEnclosingInterval(root *ast.File, start, end token.Pos) (path []ast.Node, exact bool) { return astutil.PathEnclosingInterval(root, start, end) } golang-honnef-go-tools-2024.1/go/ast/astutil/util.go000066400000000000000000000244421465704072200222670ustar00rootroot00000000000000package astutil import ( "fmt" "go/ast" "go/token" "reflect" "strings" "golang.org/x/tools/go/ast/astutil" ) func IsIdent(expr ast.Expr, ident string) bool { id, ok := expr.(*ast.Ident) return ok && id.Name == ident } // isBlank returns whether id is the blank identifier "_". // If id == nil, the answer is false. func IsBlank(id ast.Expr) bool { ident, _ := id.(*ast.Ident) return ident != nil && ident.Name == "_" } // Deprecated: use code.IsIntegerLiteral instead. func IsIntLiteral(expr ast.Expr, literal string) bool { lit, ok := expr.(*ast.BasicLit) return ok && lit.Kind == token.INT && lit.Value == literal } // Deprecated: use IsIntLiteral instead func IsZero(expr ast.Expr) bool { return IsIntLiteral(expr, "0") } func Preamble(f *ast.File) string { cutoff := f.Package if f.Doc != nil { cutoff = f.Doc.Pos() } var out []string for _, cmt := range f.Comments { if cmt.Pos() >= cutoff { break } out = append(out, cmt.Text()) } return strings.Join(out, "\n") } func GroupSpecs(fset *token.FileSet, specs []ast.Spec) [][]ast.Spec { if len(specs) == 0 { return nil } groups := make([][]ast.Spec, 1) groups[0] = append(groups[0], specs[0]) for _, spec := range specs[1:] { g := groups[len(groups)-1] if fset.PositionFor(spec.Pos(), false).Line-1 != fset.PositionFor(g[len(g)-1].End(), false).Line { groups = append(groups, nil) } groups[len(groups)-1] = append(groups[len(groups)-1], spec) } return groups } // Unparen returns e with any enclosing parentheses stripped. func Unparen(e ast.Expr) ast.Expr { for { p, ok := e.(*ast.ParenExpr) if !ok { return e } e = p.X } } // CopyExpr creates a deep copy of an expression. // It doesn't support copying FuncLits and returns ok == false when encountering one. func CopyExpr(node ast.Expr) (ast.Expr, bool) { switch node := node.(type) { case *ast.BasicLit: cp := *node return &cp, true case *ast.BinaryExpr: cp := *node var ok1, ok2 bool cp.X, ok1 = CopyExpr(cp.X) cp.Y, ok2 = CopyExpr(cp.Y) return &cp, ok1 && ok2 case *ast.CallExpr: var ok bool cp := *node cp.Fun, ok = CopyExpr(cp.Fun) if !ok { return nil, false } cp.Args = make([]ast.Expr, len(node.Args)) for i, v := range node.Args { cp.Args[i], ok = CopyExpr(v) if !ok { return nil, false } } return &cp, true case *ast.CompositeLit: var ok bool cp := *node cp.Type, ok = CopyExpr(cp.Type) if !ok { return nil, false } cp.Elts = make([]ast.Expr, len(node.Elts)) for i, v := range node.Elts { cp.Elts[i], ok = CopyExpr(v) if !ok { return nil, false } } return &cp, true case *ast.Ident: cp := *node return &cp, true case *ast.IndexExpr: var ok1, ok2 bool cp := *node cp.X, ok1 = CopyExpr(cp.X) cp.Index, ok2 = CopyExpr(cp.Index) return &cp, ok1 && ok2 case *ast.IndexListExpr: var ok bool cp := *node cp.X, ok = CopyExpr(cp.X) if !ok { return nil, false } for i, v := range node.Indices { cp.Indices[i], ok = CopyExpr(v) if !ok { return nil, false } } return &cp, true case *ast.KeyValueExpr: var ok1, ok2 bool cp := *node cp.Key, ok1 = CopyExpr(cp.Key) cp.Value, ok2 = CopyExpr(cp.Value) return &cp, ok1 && ok2 case *ast.ParenExpr: var ok bool cp := *node cp.X, ok = CopyExpr(cp.X) return &cp, ok case *ast.SelectorExpr: var ok bool cp := *node cp.X, ok = CopyExpr(cp.X) if !ok { return nil, false } sel, ok := CopyExpr(cp.Sel) if !ok { // this is impossible return nil, false } cp.Sel = sel.(*ast.Ident) return &cp, true case *ast.SliceExpr: var ok1, ok2, ok3, ok4 bool cp := *node cp.X, ok1 = CopyExpr(cp.X) cp.Low, ok2 = CopyExpr(cp.Low) cp.High, ok3 = CopyExpr(cp.High) cp.Max, ok4 = CopyExpr(cp.Max) return &cp, ok1 && ok2 && ok3 && ok4 case *ast.StarExpr: var ok bool cp := *node cp.X, ok = CopyExpr(cp.X) return &cp, ok case *ast.TypeAssertExpr: var ok1, ok2 bool cp := *node cp.X, ok1 = CopyExpr(cp.X) cp.Type, ok2 = CopyExpr(cp.Type) return &cp, ok1 && ok2 case *ast.UnaryExpr: var ok bool cp := *node cp.X, ok = CopyExpr(cp.X) return &cp, ok case *ast.MapType: var ok1, ok2 bool cp := *node cp.Key, ok1 = CopyExpr(cp.Key) cp.Value, ok2 = CopyExpr(cp.Value) return &cp, ok1 && ok2 case *ast.ArrayType: var ok1, ok2 bool cp := *node cp.Len, ok1 = CopyExpr(cp.Len) cp.Elt, ok2 = CopyExpr(cp.Elt) return &cp, ok1 && ok2 case *ast.Ellipsis: var ok bool cp := *node cp.Elt, ok = CopyExpr(cp.Elt) return &cp, ok case *ast.InterfaceType: cp := *node return &cp, true case *ast.StructType: cp := *node return &cp, true case *ast.FuncLit, *ast.FuncType: // TODO(dh): implement copying of function literals and types. return nil, false case *ast.ChanType: var ok bool cp := *node cp.Value, ok = CopyExpr(cp.Value) return &cp, ok case nil: return nil, true default: panic(fmt.Sprintf("unreachable: %T", node)) } } func Equal(a, b ast.Node) bool { if a == b { return true } if a == nil || b == nil { return false } if reflect.TypeOf(a) != reflect.TypeOf(b) { return false } switch a := a.(type) { case *ast.BasicLit: b := b.(*ast.BasicLit) return a.Kind == b.Kind && a.Value == b.Value case *ast.BinaryExpr: b := b.(*ast.BinaryExpr) return Equal(a.X, b.X) && a.Op == b.Op && Equal(a.Y, b.Y) case *ast.CallExpr: b := b.(*ast.CallExpr) if len(a.Args) != len(b.Args) { return false } for i, arg := range a.Args { if !Equal(arg, b.Args[i]) { return false } } return Equal(a.Fun, b.Fun) && (a.Ellipsis == token.NoPos && b.Ellipsis == token.NoPos || a.Ellipsis != token.NoPos && b.Ellipsis != token.NoPos) case *ast.CompositeLit: b := b.(*ast.CompositeLit) if len(a.Elts) != len(b.Elts) { return false } for i, elt := range b.Elts { if !Equal(elt, b.Elts[i]) { return false } } return Equal(a.Type, b.Type) && a.Incomplete == b.Incomplete case *ast.Ident: b := b.(*ast.Ident) return a.Name == b.Name case *ast.IndexExpr: b := b.(*ast.IndexExpr) return Equal(a.X, b.X) && Equal(a.Index, b.Index) case *ast.IndexListExpr: b := b.(*ast.IndexListExpr) if len(a.Indices) != len(b.Indices) { return false } for i, v := range a.Indices { if !Equal(v, b.Indices[i]) { return false } } return Equal(a.X, b.X) case *ast.KeyValueExpr: b := b.(*ast.KeyValueExpr) return Equal(a.Key, b.Key) && Equal(a.Value, b.Value) case *ast.ParenExpr: b := b.(*ast.ParenExpr) return Equal(a.X, b.X) case *ast.SelectorExpr: b := b.(*ast.SelectorExpr) return Equal(a.X, b.X) && Equal(a.Sel, b.Sel) case *ast.SliceExpr: b := b.(*ast.SliceExpr) return Equal(a.X, b.X) && Equal(a.Low, b.Low) && Equal(a.High, b.High) && Equal(a.Max, b.Max) && a.Slice3 == b.Slice3 case *ast.StarExpr: b := b.(*ast.StarExpr) return Equal(a.X, b.X) case *ast.TypeAssertExpr: b := b.(*ast.TypeAssertExpr) return Equal(a.X, b.X) && Equal(a.Type, b.Type) case *ast.UnaryExpr: b := b.(*ast.UnaryExpr) return a.Op == b.Op && Equal(a.X, b.X) case *ast.MapType: b := b.(*ast.MapType) return Equal(a.Key, b.Key) && Equal(a.Value, b.Value) case *ast.ArrayType: b := b.(*ast.ArrayType) return Equal(a.Len, b.Len) && Equal(a.Elt, b.Elt) case *ast.Ellipsis: b := b.(*ast.Ellipsis) return Equal(a.Elt, b.Elt) case *ast.InterfaceType: b := b.(*ast.InterfaceType) return a.Incomplete == b.Incomplete && Equal(a.Methods, b.Methods) case *ast.StructType: b := b.(*ast.StructType) return a.Incomplete == b.Incomplete && Equal(a.Fields, b.Fields) case *ast.FuncLit: // TODO(dh): support function literals return false case *ast.ChanType: b := b.(*ast.ChanType) return a.Dir == b.Dir && (a.Arrow == token.NoPos && b.Arrow == token.NoPos || a.Arrow != token.NoPos && b.Arrow != token.NoPos) case *ast.FieldList: b := b.(*ast.FieldList) if len(a.List) != len(b.List) { return false } for i, fieldA := range a.List { if !Equal(fieldA, b.List[i]) { return false } } return true case *ast.Field: b := b.(*ast.Field) if len(a.Names) != len(b.Names) { return false } for j, name := range a.Names { if !Equal(name, b.Names[j]) { return false } } if !Equal(a.Type, b.Type) || !Equal(a.Tag, b.Tag) { return false } return true default: panic(fmt.Sprintf("unreachable: %T", a)) } } func NegateDeMorgan(expr ast.Expr, recursive bool) ast.Expr { switch expr := expr.(type) { case *ast.BinaryExpr: var out ast.BinaryExpr switch expr.Op { case token.EQL: out.X = expr.X out.Op = token.NEQ out.Y = expr.Y case token.LSS: out.X = expr.X out.Op = token.GEQ out.Y = expr.Y case token.GTR: out.X = expr.X out.Op = token.LEQ out.Y = expr.Y case token.NEQ: out.X = expr.X out.Op = token.EQL out.Y = expr.Y case token.LEQ: out.X = expr.X out.Op = token.GTR out.Y = expr.Y case token.GEQ: out.X = expr.X out.Op = token.LSS out.Y = expr.Y case token.LAND: out.X = NegateDeMorgan(expr.X, recursive) out.Op = token.LOR out.Y = NegateDeMorgan(expr.Y, recursive) case token.LOR: out.X = NegateDeMorgan(expr.X, recursive) out.Op = token.LAND out.Y = NegateDeMorgan(expr.Y, recursive) } return &out case *ast.ParenExpr: if recursive { return &ast.ParenExpr{ X: NegateDeMorgan(expr.X, recursive), } } else { return &ast.UnaryExpr{ Op: token.NOT, X: expr, } } case *ast.UnaryExpr: if expr.Op == token.NOT { return expr.X } else { return &ast.UnaryExpr{ Op: token.NOT, X: expr, } } default: return &ast.UnaryExpr{ Op: token.NOT, X: expr, } } } func SimplifyParentheses(node ast.Expr) ast.Expr { var changed bool // XXX accept list of ops to operate on // XXX copy AST node, don't modify in place post := func(c *astutil.Cursor) bool { out := c.Node() if paren, ok := c.Node().(*ast.ParenExpr); ok { out = paren.X } if binop, ok := out.(*ast.BinaryExpr); ok { if right, ok := binop.Y.(*ast.BinaryExpr); ok && binop.Op == right.Op { // XXX also check that Op is associative root := binop pivot := root.Y.(*ast.BinaryExpr) root.Y = pivot.X pivot.X = root root = pivot out = root } } if out != c.Node() { changed = true c.Replace(out) } return true } for changed = true; changed; { changed = false node = astutil.Apply(node, nil, post).(ast.Expr) } return node } golang-honnef-go-tools-2024.1/go/buildid/000077500000000000000000000000001465704072200201155ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/go/buildid/UPSTREAM000066400000000000000000000004041465704072200212760ustar00rootroot00000000000000This package extracts buildid.go and note.go from cmd/internal/buildid/. We have modified it to remove support for AIX big archive files, to cut down on our dependencies. The last upstream commit we've looked at was: e8ee1dc4f9e2632ba1018610d1a1187743ae397f golang-honnef-go-tools-2024.1/go/buildid/buildid.go000066400000000000000000000135101465704072200220600ustar00rootroot00000000000000// Copyright 2017 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. package buildid import ( "bytes" "debug/elf" "errors" "fmt" "io" "os" "strconv" "strings" ) var errBuildIDMalformed = fmt.Errorf("malformed object file") var ( bangArch = []byte("!") pkgdef = []byte("__.PKGDEF") goobject = []byte("go object ") buildid = []byte("build id ") ) // ReadFile reads the build ID from an archive or executable file. func ReadFile(name string) (id string, err error) { f, err := os.Open(name) if err != nil { return "", err } defer f.Close() buf := make([]byte, 8) if _, err := f.ReadAt(buf, 0); err != nil { return "", err } if string(buf) != "!\n" { if string(buf) == "\n" { return "", errors.New("unsupported") } return readBinary(name, f) } // Read just enough of the target to fetch the build ID. // The archive is expected to look like: // // ! // __.PKGDEF 0 0 0 644 7955 ` // go object darwin amd64 devel X:none // build id "b41e5c45250e25c9fd5e9f9a1de7857ea0d41224" // // The variable-sized strings are GOOS, GOARCH, and the experiment list (X:none). // Reading the first 1024 bytes should be plenty. data := make([]byte, 1024) n, err := io.ReadFull(f, data) if err != nil && n == 0 { return "", err } tryGccgo := func() (string, error) { return readGccgoArchive(name, f) } // Archive header. for i := 0; ; i++ { // returns during i==3 j := bytes.IndexByte(data, '\n') if j < 0 { return tryGccgo() } line := data[:j] data = data[j+1:] switch i { case 0: if !bytes.Equal(line, bangArch) { return tryGccgo() } case 1: if !bytes.HasPrefix(line, pkgdef) { return tryGccgo() } case 2: if !bytes.HasPrefix(line, goobject) { return tryGccgo() } case 3: if !bytes.HasPrefix(line, buildid) { // Found the object header, just doesn't have a build id line. // Treat as successful, with empty build id. return "", nil } id, err := strconv.Unquote(string(line[len(buildid):])) if err != nil { return tryGccgo() } return id, nil } } } // readGccgoArchive tries to parse the archive as a standard Unix // archive file, and fetch the build ID from the _buildid.o entry. // The _buildid.o entry is written by (*Builder).gccgoBuildIDELFFile // in cmd/go/internal/work/exec.go. func readGccgoArchive(name string, f *os.File) (string, error) { bad := func() (string, error) { return "", &os.PathError{Op: "parse", Path: name, Err: errBuildIDMalformed} } off := int64(8) for { if _, err := f.Seek(off, io.SeekStart); err != nil { return "", err } // TODO(iant): Make a debug/ar package, and use it // here and in cmd/link. var hdr [60]byte if _, err := io.ReadFull(f, hdr[:]); err != nil { if err == io.EOF { // No more entries, no build ID. return "", nil } return "", err } off += 60 sizeStr := strings.TrimSpace(string(hdr[48:58])) size, err := strconv.ParseInt(sizeStr, 0, 64) if err != nil { return bad() } name := strings.TrimSpace(string(hdr[:16])) if name == "_buildid.o/" { sr := io.NewSectionReader(f, off, size) e, err := elf.NewFile(sr) if err != nil { return bad() } s := e.Section(".go.buildid") if s == nil { return bad() } data, err := s.Data() if err != nil { return bad() } return string(data), nil } off += size if off&1 != 0 { off++ } } } var ( goBuildPrefix = []byte("\xff Go build ID: \"") goBuildEnd = []byte("\"\n \xff") elfPrefix = []byte("\x7fELF") machoPrefixes = [][]byte{ {0xfe, 0xed, 0xfa, 0xce}, {0xfe, 0xed, 0xfa, 0xcf}, {0xce, 0xfa, 0xed, 0xfe}, {0xcf, 0xfa, 0xed, 0xfe}, } ) var readSize = 32 * 1024 // changed for testing // readBinary reads the build ID from a binary. // // ELF binaries store the build ID in a proper PT_NOTE section. // // Other binary formats are not so flexible. For those, the linker // stores the build ID as non-instruction bytes at the very beginning // of the text segment, which should appear near the beginning // of the file. This is clumsy but fairly portable. Custom locations // can be added for other binary types as needed, like we did for ELF. func readBinary(name string, f *os.File) (id string, err error) { // Read the first 32 kB of the binary file. // That should be enough to find the build ID. // In ELF files, the build ID is in the leading headers, // which are typically less than 4 kB, not to mention 32 kB. // In Mach-O files, there's no limit, so we have to parse the file. // On other systems, we're trying to read enough that // we get the beginning of the text segment in the read. // The offset where the text segment begins in a hello // world compiled for each different object format today: // // Plan 9: 0x20 // Windows: 0x600 // data := make([]byte, readSize) _, err = io.ReadFull(f, data) if err == io.ErrUnexpectedEOF { err = nil } if err != nil { return "", err } if bytes.HasPrefix(data, elfPrefix) { return readELF(name, f, data) } for _, m := range machoPrefixes { if bytes.HasPrefix(data, m) { return readMacho(name, f, data) } } return readRaw(name, data) } // readRaw finds the raw build ID stored in text segment data. func readRaw(name string, data []byte) (id string, err error) { i := bytes.Index(data, goBuildPrefix) if i < 0 { // Missing. Treat as successful but build ID empty. return "", nil } j := bytes.Index(data[i+len(goBuildPrefix):], goBuildEnd) if j < 0 { return "", &os.PathError{Op: "parse", Path: name, Err: errBuildIDMalformed} } quoted := data[i+len(goBuildPrefix)-1 : i+len(goBuildPrefix)+j+1] id, err = strconv.Unquote(string(quoted)) if err != nil { return "", &os.PathError{Op: "parse", Path: name, Err: errBuildIDMalformed} } return id, nil } golang-honnef-go-tools-2024.1/go/buildid/note.go000066400000000000000000000134211465704072200214120ustar00rootroot00000000000000// 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. package buildid import ( "bytes" "debug/elf" "debug/macho" "encoding/binary" "fmt" "io" "os" ) func readAligned4(r io.Reader, sz int32) ([]byte, error) { full := (sz + 3) &^ 3 data := make([]byte, full) _, err := io.ReadFull(r, data) if err != nil { return nil, err } data = data[:sz] return data, nil } func ReadELFNote(filename, name string, typ int32) ([]byte, error) { f, err := elf.Open(filename) if err != nil { return nil, err } defer f.Close() for _, sect := range f.Sections { if sect.Type != elf.SHT_NOTE { continue } r := sect.Open() for { var namesize, descsize, noteType int32 err = binary.Read(r, f.ByteOrder, &namesize) if err != nil { if err == io.EOF { break } return nil, fmt.Errorf("read namesize failed: %v", err) } err = binary.Read(r, f.ByteOrder, &descsize) if err != nil { return nil, fmt.Errorf("read descsize failed: %v", err) } err = binary.Read(r, f.ByteOrder, ¬eType) if err != nil { return nil, fmt.Errorf("read type failed: %v", err) } noteName, err := readAligned4(r, namesize) if err != nil { return nil, fmt.Errorf("read name failed: %v", err) } desc, err := readAligned4(r, descsize) if err != nil { return nil, fmt.Errorf("read desc failed: %v", err) } if name == string(noteName) && typ == noteType { return desc, nil } } } return nil, nil } var elfGoNote = []byte("Go\x00\x00") var elfGNUNote = []byte("GNU\x00") // The Go build ID is stored in a note described by an ELF PT_NOTE prog // header. The caller has already opened filename, to get f, and read // at least 4 kB out, in data. func readELF(name string, f *os.File, data []byte) (buildid string, err error) { // Assume the note content is in the data, already read. // Rewrite the ELF header to set shnum to 0, so that we can pass // the data to elf.NewFile and it will decode the Prog list but not // try to read the section headers and the string table from disk. // That's a waste of I/O when all we care about is the Prog list // and the one ELF note. switch elf.Class(data[elf.EI_CLASS]) { case elf.ELFCLASS32: data[48] = 0 data[49] = 0 case elf.ELFCLASS64: data[60] = 0 data[61] = 0 } const elfGoBuildIDTag = 4 const gnuBuildIDTag = 3 ef, err := elf.NewFile(bytes.NewReader(data)) if err != nil { return "", &os.PathError{Path: name, Op: "parse", Err: err} } var gnu string for _, p := range ef.Progs { if p.Type != elf.PT_NOTE || p.Filesz < 16 { continue } var note []byte if p.Off+p.Filesz < uint64(len(data)) { note = data[p.Off : p.Off+p.Filesz] } else { // For some linkers, such as the Solaris linker, // the buildid may not be found in data (which // likely contains the first 16kB of the file) // or even the first few megabytes of the file // due to differences in note segment placement; // in that case, extract the note data manually. _, err = f.Seek(int64(p.Off), io.SeekStart) if err != nil { return "", err } note = make([]byte, p.Filesz) _, err = io.ReadFull(f, note) if err != nil { return "", err } } filesz := p.Filesz off := p.Off for filesz >= 16 { nameSize := ef.ByteOrder.Uint32(note) valSize := ef.ByteOrder.Uint32(note[4:]) tag := ef.ByteOrder.Uint32(note[8:]) nname := note[12:16] if nameSize == 4 && 16+valSize <= uint32(len(note)) && tag == elfGoBuildIDTag && bytes.Equal(nname, elfGoNote) { return string(note[16 : 16+valSize]), nil } if nameSize == 4 && 16+valSize <= uint32(len(note)) && tag == gnuBuildIDTag && bytes.Equal(nname, elfGNUNote) { gnu = string(note[16 : 16+valSize]) } nameSize = (nameSize + 3) &^ 3 valSize = (valSize + 3) &^ 3 notesz := uint64(12 + nameSize + valSize) if filesz <= notesz { break } off += notesz align := p.Align alignedOff := (off + align - 1) &^ (align - 1) notesz += alignedOff - off off = alignedOff filesz -= notesz note = note[notesz:] } } // If we didn't find a Go note, use a GNU note if available. // This is what gccgo uses. if gnu != "" { return gnu, nil } // No note. Treat as successful but build ID empty. return "", nil } // The Go build ID is stored at the beginning of the Mach-O __text segment. // The caller has already opened filename, to get f, and read a few kB out, in data. // Sadly, that's not guaranteed to hold the note, because there is an arbitrary amount // of other junk placed in the file ahead of the main text. func readMacho(name string, f *os.File, data []byte) (buildid string, err error) { // If the data we want has already been read, don't worry about Mach-O parsing. // This is both an optimization and a hedge against the Mach-O parsing failing // in the future due to, for example, the name of the __text section changing. if b, err := readRaw(name, data); b != "" && err == nil { return b, err } mf, err := macho.NewFile(f) if err != nil { return "", &os.PathError{Path: name, Op: "parse", Err: err} } sect := mf.Section("__text") if sect == nil { // Every binary has a __text section. Something is wrong. return "", &os.PathError{Path: name, Op: "parse", Err: fmt.Errorf("cannot find __text section")} } // It should be in the first few bytes, but read a lot just in case, // especially given our past problems on OS X with the build ID moving. // There shouldn't be much difference between reading 4kB and 32kB: // the hard part is getting to the data, not transferring it. n := sect.Size if n > uint64(readSize) { n = uint64(readSize) } buf := make([]byte, n) if _, err := f.ReadAt(buf, int64(sect.Offset)); err != nil { return "", err } return readRaw(name, buf) } golang-honnef-go-tools-2024.1/go/gcsizes/000077500000000000000000000000001465704072200201505ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/go/gcsizes/LICENSE000066400000000000000000000027071465704072200211630ustar00rootroot00000000000000Copyright (c) 2009 The Go Authors. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Google Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. golang-honnef-go-tools-2024.1/go/gcsizes/sizes.go000066400000000000000000000053301465704072200216350ustar00rootroot00000000000000// Copyright 2013 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. // Package gcsizes provides a types.Sizes implementation that adheres // to the rules used by the gc compiler. package gcsizes import ( "go/build" "go/types" ) type Sizes struct { WordSize int64 MaxAlign int64 } // ForArch returns a correct Sizes for the given architecture. func ForArch(arch string) *Sizes { wordSize := int64(8) maxAlign := int64(8) switch build.Default.GOARCH { case "386", "arm": wordSize, maxAlign = 4, 4 case "amd64p32": wordSize = 4 } return &Sizes{WordSize: wordSize, MaxAlign: maxAlign} } func (s *Sizes) Alignof(T types.Type) int64 { switch t := T.Underlying().(type) { case *types.Array: return s.Alignof(t.Elem()) case *types.Struct: max := int64(1) n := t.NumFields() var fields []*types.Var for i := 0; i < n; i++ { fields = append(fields, t.Field(i)) } for _, f := range fields { if a := s.Alignof(f.Type()); a > max { max = a } } return max } a := s.Sizeof(T) // may be 0 if a < 1 { return 1 } if a > s.MaxAlign { return s.MaxAlign } return a } func (s *Sizes) Offsetsof(fields []*types.Var) []int64 { offsets := make([]int64, len(fields)) var o int64 for i, f := range fields { a := s.Alignof(f.Type()) o = align(o, a) offsets[i] = o o += s.Sizeof(f.Type()) } return offsets } var basicSizes = [...]byte{ types.Bool: 1, types.Int8: 1, types.Int16: 2, types.Int32: 4, types.Int64: 8, types.Uint8: 1, types.Uint16: 2, types.Uint32: 4, types.Uint64: 8, types.Float32: 4, types.Float64: 8, types.Complex64: 8, types.Complex128: 16, } func (s *Sizes) Sizeof(T types.Type) int64 { switch t := T.Underlying().(type) { case *types.Basic: k := t.Kind() if int(k) < len(basicSizes) { if s := basicSizes[k]; s > 0 { return int64(s) } } if k == types.String { return s.WordSize * 2 } case *types.Array: n := t.Len() if n == 0 { return 0 } a := s.Alignof(t.Elem()) z := s.Sizeof(t.Elem()) return align(z, a)*(n-1) + z case *types.Slice: return s.WordSize * 3 case *types.Struct: n := t.NumFields() if n == 0 { return 0 } var fields []*types.Var for i := 0; i < n; i++ { fields = append(fields, t.Field(i)) } offsets := s.Offsetsof(fields) a := s.Alignof(T) lsz := s.Sizeof(fields[n-1].Type()) if lsz == 0 { lsz = 1 } z := offsets[n-1] + lsz return align(z, a) case *types.Interface: return s.WordSize * 2 } return s.WordSize // catch-all } // align returns the smallest y >= x such that y % a == 0. func align(x, a int64) int64 { y := x + a - 1 return y - y%a } golang-honnef-go-tools-2024.1/go/ir/000077500000000000000000000000001465704072200171135ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/go/ir/LICENSE000066400000000000000000000027771465704072200201350ustar00rootroot00000000000000Copyright (c) 2009 The Go Authors. All rights reserved. Copyright (c) 2016 Dominik Honnef. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Google Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. golang-honnef-go-tools-2024.1/go/ir/UPSTREAM000066400000000000000000000007131465704072200202770ustar00rootroot00000000000000This package started as a copy of golang.org/x/tools/go/ssa, imported from an unknown commit in 2016. It has since been heavily modified to match our own needs in an IR. The changes are too many to list here, and it is best to consider this package independent of go/ssa. Upstream changes still get applied when they address bugs in portions of code we have inherited. The last upstream commit we've looked at was: ac2946029ad3806349fa00546449da9f59320e89 golang-honnef-go-tools-2024.1/go/ir/bench_test.go000066400000000000000000000014721465704072200215640ustar00rootroot00000000000000package ir_test import ( "testing" "golang.org/x/tools/go/packages" "honnef.co/go/tools/go/ir" ) func BenchmarkSSA(b *testing.B) { cfg := &packages.Config{ Mode: packages.NeedSyntax | packages.NeedTypes | packages.NeedTypesInfo, Tests: false, } pkgs, err := packages.Load(cfg, "std") if err != nil { b.Fatal(err) } b.ResetTimer() for i := 0; i < b.N; i++ { prog := ir.NewProgram(pkgs[0].Fset, ir.GlobalDebug) seen := map[*packages.Package]struct{}{} var create func(pkg *packages.Package) create = func(pkg *packages.Package) { if _, ok := seen[pkg]; ok { return } seen[pkg] = struct{}{} prog.CreatePackage(pkg.Types, pkg.Syntax, pkg.TypesInfo, true) for _, imp := range pkg.Imports { create(imp) } } for _, pkg := range pkgs { create(pkg) } prog.Build() } } golang-honnef-go-tools-2024.1/go/ir/blockopt.go000066400000000000000000000120271465704072200212610ustar00rootroot00000000000000// Copyright 2013 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. package ir // Simple block optimizations to simplify the control flow graph. // TODO(adonovan): opt: instead of creating several "unreachable" blocks // per function in the Builder, reuse a single one (e.g. at Blocks[1]) // to reduce garbage. import ( "fmt" "os" ) // If true, perform sanity checking and show progress at each // successive iteration of optimizeBlocks. Very verbose. const debugBlockOpt = false // markReachable sets Index=-1 for all blocks reachable from b. func markReachable(b *BasicBlock) { b.gaps = -1 for _, succ := range b.Succs { if succ.gaps == 0 { markReachable(succ) } } } // deleteUnreachableBlocks marks all reachable blocks of f and // eliminates (nils) all others, including possibly cyclic subgraphs. func deleteUnreachableBlocks(f *Function) { const white, black = 0, -1 // We borrow b.gaps temporarily as the mark bit. for _, b := range f.Blocks { b.gaps = white } markReachable(f.Blocks[0]) // In SSI form, we need the exit to be reachable for correct // post-dominance information. In original form, however, we // cannot unconditionally mark it reachable because we won't // be adding fake edges, and this breaks the calculation of // dominance information. markReachable(f.Exit) for i, b := range f.Blocks { if b.gaps == white { for _, c := range b.Succs { if c.gaps == black { c.removePred(b) // delete white->black edge } } if debugBlockOpt { fmt.Fprintln(os.Stderr, "unreachable", b) } f.Blocks[i] = nil // delete b } } f.removeNilBlocks() } // jumpThreading attempts to apply simple jump-threading to block b, // in which a->b->c become a->c if b is just a Jump. // The result is true if the optimization was applied. func jumpThreading(f *Function, b *BasicBlock) bool { if b.Index == 0 { return false // don't apply to entry block } if b.Instrs == nil { return false } for _, pred := range b.Preds { switch pred.Control().(type) { case *ConstantSwitch: // don't optimize away the head blocks of switch statements return false } } if _, ok := b.Instrs[0].(*Jump); !ok { return false // not just a jump } c := b.Succs[0] if c == b { return false // don't apply to degenerate jump-to-self. } if c.hasPhi() { return false // not sound without more effort } for j, a := range b.Preds { a.replaceSucc(b, c) // If a now has two edges to c, replace its degenerate If by Jump. if len(a.Succs) == 2 && a.Succs[0] == c && a.Succs[1] == c { jump := new(Jump) jump.setBlock(a) a.Instrs[len(a.Instrs)-1] = jump a.Succs = a.Succs[:1] c.removePred(b) } else { if j == 0 { c.replacePred(b, a) } else { c.Preds = append(c.Preds, a) } } if debugBlockOpt { fmt.Fprintln(os.Stderr, "jumpThreading", a, b, c) } } f.Blocks[b.Index] = nil // delete b return true } // fuseBlocks attempts to apply the block fusion optimization to block // a, in which a->b becomes ab if len(a.Succs)==len(b.Preds)==1. // The result is true if the optimization was applied. func fuseBlocks(f *Function, a *BasicBlock) bool { if len(a.Succs) != 1 { return false } if a.Succs[0] == f.Exit { return false } b := a.Succs[0] if len(b.Preds) != 1 { return false } if _, ok := a.Instrs[len(a.Instrs)-1].(*Panic); ok { // panics aren't simple jumps, they have side effects. return false } // Degenerate &&/|| ops may result in a straight-line CFG // containing φ-nodes. (Ideally we'd replace such them with // their sole operand but that requires Referrers, built later.) if b.hasPhi() { return false // not sound without further effort } // Eliminate jump at end of A, then copy all of B across. a.Instrs = append(a.Instrs[:len(a.Instrs)-1], b.Instrs...) for _, instr := range b.Instrs { instr.setBlock(a) } // A inherits B's successors a.Succs = append(a.succs2[:0], b.Succs...) // Fix up Preds links of all successors of B. for _, c := range b.Succs { c.replacePred(b, a) } if debugBlockOpt { fmt.Fprintln(os.Stderr, "fuseBlocks", a, b) } f.Blocks[b.Index] = nil // delete b return true } // optimizeBlocks() performs some simple block optimizations on a // completed function: dead block elimination, block fusion, jump // threading. func optimizeBlocks(f *Function) { if debugBlockOpt { f.WriteTo(os.Stderr) mustSanityCheck(f, nil) } deleteUnreachableBlocks(f) // Loop until no further progress. changed := true for changed { changed = false if debugBlockOpt { f.WriteTo(os.Stderr) mustSanityCheck(f, nil) } for _, b := range f.Blocks { // f.Blocks will temporarily contain nils to indicate // deleted blocks; we remove them at the end. if b == nil { continue } // Fuse blocks. b->c becomes bc. if fuseBlocks(f, b) { changed = true } // a->b->c becomes a->c if b contains only a Jump. if jumpThreading(f, b) { changed = true continue // (b was disconnected) } } } f.removeNilBlocks() } golang-honnef-go-tools-2024.1/go/ir/builder.go000066400000000000000000003007321465704072200210750ustar00rootroot00000000000000// Copyright 2013 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. package ir // This file implements the BUILD phase of IR construction. // // IR construction has two phases, CREATE and BUILD. In the CREATE phase // (create.go), all packages are constructed and type-checked and // definitions of all package members are created, method-sets are // computed, and wrapper methods are synthesized. // ir.Packages are created in arbitrary order. // // In the BUILD phase (builder.go), the builder traverses the AST of // each Go source function and generates IR instructions for the // function body. Initializer expressions for package-level variables // are emitted to the package's init() function in the order specified // by go/types.Info.InitOrder, then code for each function in the // package is generated in lexical order. // // The builder's and Program's indices (maps) are populated and // mutated during the CREATE phase, but during the BUILD phase they // remain constant. The sole exception is Prog.methodSets and its // related maps, which are protected by a dedicated mutex. import ( "fmt" "go/ast" "go/constant" "go/token" "go/types" "go/version" "os" "honnef.co/go/tools/analysis/lint" "honnef.co/go/tools/go/types/typeutil" "golang.org/x/exp/typeparams" ) var ( varOk = newVar("ok", tBool) varIndex = newVar("index", tInt) // Type constants. tBool = types.Typ[types.Bool] tInt = types.Typ[types.Int] tInvalid = types.Typ[types.Invalid] tString = types.Typ[types.String] tUntypedNil = types.Typ[types.UntypedNil] tEface = types.NewInterfaceType(nil, nil).Complete() tDeferStack = types.NewPointer(typeutil.NewDeferStack()) vDeferStack = &Builtin{ name: "ssa:deferstack", sig: types.NewSignatureType(nil, nil, nil, nil, types.NewTuple(anonVar(tDeferStack)), false), } ) // range-over-func jump is READY func jReady() *Const { c := intConst(0, nil) c.comment = "rangefunc.exit.ready" return c } // range-over-func jump is BUSY func jBusy() *Const { c := intConst(-1, nil) c.comment = "rangefunc.exit.busy" return c } // range-over-func jump is DONE func jDone() *Const { c := intConst(-2, nil) c.comment = "rangefunc.exit.done" return c } // builder holds state associated with the package currently being built. // Its methods contain all the logic for AST-to-IR conversion. type builder struct { printFunc string blocksets [5]BlockSet } // cond emits to fn code to evaluate boolean condition e and jump // to t or f depending on its value, performing various simplifications. // // Postcondition: fn.currentBlock is nil. func (b *builder) cond(fn *Function, e ast.Expr, t, f *BasicBlock) *If { switch e := e.(type) { case *ast.ParenExpr: return b.cond(fn, e.X, t, f) case *ast.BinaryExpr: switch e.Op { case token.LAND: ltrue := fn.newBasicBlock("cond.true") b.cond(fn, e.X, ltrue, f) fn.currentBlock = ltrue return b.cond(fn, e.Y, t, f) case token.LOR: lfalse := fn.newBasicBlock("cond.false") b.cond(fn, e.X, t, lfalse) fn.currentBlock = lfalse return b.cond(fn, e.Y, t, f) } case *ast.UnaryExpr: if e.Op == token.NOT { return b.cond(fn, e.X, f, t) } } // A traditional compiler would simplify "if false" (etc) here // but we do not, for better fidelity to the source code. // // The value of a constant condition may be platform-specific, // and may cause blocks that are reachable in some configuration // to be hidden from subsequent analyses such as bug-finding tools. return emitIf(fn, b.expr(fn, e), t, f, e) } // logicalBinop emits code to fn to evaluate e, a &&- or // ||-expression whose reified boolean value is wanted. // The value is returned. func (b *builder) logicalBinop(fn *Function, e *ast.BinaryExpr) Value { rhs := fn.newBasicBlock("binop.rhs") done := fn.newBasicBlock("binop.done") // T(e) = T(e.X) = T(e.Y) after untyped constants have been // eliminated. // TODO(adonovan): not true; MyBool==MyBool yields UntypedBool. t := fn.Pkg.typeOf(e) var short Value // value of the short-circuit path switch e.Op { case token.LAND: b.cond(fn, e.X, rhs, done) short = emitConst(fn, NewConst(constant.MakeBool(false), t, e)) case token.LOR: b.cond(fn, e.X, done, rhs) short = emitConst(fn, NewConst(constant.MakeBool(true), t, e)) } // Is rhs unreachable? if rhs.Preds == nil { // Simplify false&&y to false, true||y to true. fn.currentBlock = done return short } // Is done unreachable? if done.Preds == nil { // Simplify true&&y (or false||y) to y. fn.currentBlock = rhs return b.expr(fn, e.Y) } // All edges from e.X to done carry the short-circuit value. var edges []Value for range done.Preds { edges = append(edges, short) } // The edge from e.Y to done carries the value of e.Y. fn.currentBlock = rhs edges = append(edges, b.expr(fn, e.Y)) emitJump(fn, done, e) fn.currentBlock = done phi := &Phi{Edges: edges} phi.typ = t phi.comment = e.Op.String() return done.emit(phi, e) } // exprN lowers a multi-result expression e to IR form, emitting code // to fn and returning a single Value whose type is a *types.Tuple. // The caller must access the components via Extract. // // Multi-result expressions include CallExprs in a multi-value // assignment or return statement, and "value,ok" uses of // TypeAssertExpr, IndexExpr (when X is a map), and Recv. func (b *builder) exprN(fn *Function, e ast.Expr) Value { typ := fn.Pkg.typeOf(e).(*types.Tuple) switch e := e.(type) { case *ast.ParenExpr: return b.exprN(fn, e.X) case *ast.CallExpr: // Currently, no built-in function nor type conversion // has multiple results, so we can avoid some of the // cases for single-valued CallExpr. var c Call b.setCall(fn, e, &c.Call) c.typ = typ return fn.emit(&c, e) case *ast.IndexExpr: mapt := typeutil.CoreType(fn.Pkg.typeOf(e.X)).Underlying().(*types.Map) lookup := &MapLookup{ X: b.expr(fn, e.X), Index: emitConv(fn, b.expr(fn, e.Index), mapt.Key(), e), CommaOk: true, } lookup.setType(typ) return fn.emit(lookup, e) case *ast.TypeAssertExpr: return emitTypeTest(fn, b.expr(fn, e.X), typ.At(0).Type(), e) case *ast.UnaryExpr: // must be receive <- return emitRecv(fn, b.expr(fn, e.X), true, typ, e) } panic(fmt.Sprintf("exprN(%T) in %s", e, fn)) } // builtin emits to fn IR instructions to implement a call to the // built-in function obj with the specified arguments // and return type. It returns the value defined by the result. // // The result is nil if no special handling was required; in this case // the caller should treat this like an ordinary library function // call. func (b *builder) builtin(fn *Function, obj *types.Builtin, args []ast.Expr, typ types.Type, source ast.Node) Value { switch obj.Name() { case "make": styp := typ.Underlying() if _, ok := typ.Underlying().(*types.Interface); ok { // This must be a type parameter with a core type. // Set styp to the core type and generate instructions based on it. assert(typeparams.IsTypeParam(typ)) styp = typeutil.CoreType(typ) assert(styp != nil) } switch styp.(type) { case *types.Slice: n := b.expr(fn, args[1]) m := n if len(args) == 3 { m = b.expr(fn, args[2]) } if m, ok := m.(*Const); ok { // treat make([]T, n, m) as new([m]T)[:n] cap := m.Int64() at := types.NewArray(styp.Underlying().(*types.Slice).Elem(), cap) v := &Slice{ X: emitNew(fn, at, source, "makeslice"), High: n, } v.setType(typ) return fn.emit(v, source) } v := &MakeSlice{ Len: n, Cap: m, } v.setType(typ) return fn.emit(v, source) case *types.Map: var res Value if len(args) == 2 { res = b.expr(fn, args[1]) } v := &MakeMap{Reserve: res} v.setType(typ) return fn.emit(v, source) case *types.Chan: var sz Value = emitConst(fn, intConst(0, source)) if len(args) == 2 { sz = b.expr(fn, args[1]) } v := &MakeChan{Size: sz} v.setType(typ) return fn.emit(v, source) default: lint.ExhaustiveTypeSwitch(typ.Underlying()) } case "new": return emitNew(fn, deref(typ), source, "new") case "len", "cap": // Special case: len or cap of an array or *array is based on the type, not the value which may be nil. We must // still evaluate the value, though. (If it was side-effect free, the whole call would have been // constant-folded.) // // For example, for len(gen()), we need to evaluate gen() for its side-effects, but don't need the returned // value to determine the length of the array, which is constant. // // Technically this shouldn't apply to type parameters because their length/capacity is never constant. We still // choose to treat them as constant so that users of the IR get the practically constant length for free. t := typeutil.CoreType(deref(fn.Pkg.typeOf(args[0]))) if at, ok := t.(*types.Array); ok { b.expr(fn, args[0]) // for effects only return emitConst(fn, intConst(at.Len(), args[0])) } // Otherwise treat as normal. case "panic": fn.emit(&Panic{ X: emitConv(fn, b.expr(fn, args[0]), tEface, source), }, source) addEdge(fn.currentBlock, fn.Exit) fn.currentBlock = fn.newBasicBlock("unreachable") return emitConst(fn, NewConst(constant.MakeBool(true), tBool, nil)) // any non-nil Value will do } return nil // treat all others as a regular function call } // addr lowers a single-result addressable expression e to IR form, // emitting code to fn and returning the location (an lvalue) defined // by the expression. // // If escaping is true, addr marks the base variable of the // addressable expression e as being a potentially escaping pointer // value. For example, in this code: // // a := A{ // b: [1]B{B{c: 1}} // } // return &a.b[0].c // // the application of & causes a.b[0].c to have its address taken, // which means that ultimately the local variable a must be // heap-allocated. This is a simple but very conservative escape // analysis. // // Operations forming potentially escaping pointers include: // - &x, including when implicit in method call or composite literals. // - a[:] iff a is an array (not *array) // - references to variables in lexically enclosing functions. func (b *builder) addr(fn *Function, e ast.Expr, escaping bool) (RET lvalue) { switch e := e.(type) { case *ast.Ident: if isBlankIdent(e) { return blank{} } obj := fn.Pkg.objectOf(e) v := fn.Prog.packageLevelValue(obj) // var (address) if v == nil { v = fn.lookup(obj.(*types.Var), escaping) } return &address{addr: v, expr: e} case *ast.CompositeLit: t := deref(fn.Pkg.typeOf(e)) var v *Alloc if escaping { v = emitNew(fn, t, e, "complit") } else { v = emitLocal(fn, t, e, "complit") } var sb storebuf b.compLit(fn, v, e, true, &sb) sb.emit(fn) return &address{addr: v, expr: e} case *ast.ParenExpr: return b.addr(fn, e.X, escaping) case *ast.SelectorExpr: sel, ok := fn.Pkg.info.Selections[e] if !ok { // qualified identifier return b.addr(fn, e.Sel, escaping) } if sel.Kind() != types.FieldVal { panic(sel) } wantAddr := true v := b.receiver(fn, e.X, wantAddr, escaping, sel, e) index := sel.Index()[len(sel.Index())-1] vut := typeutil.CoreType(deref(v.Type())).Underlying().(*types.Struct) fld := vut.Field(index) // Due to the two phases of resolving AssignStmt, a panic from x.f = p() // when x is nil is required to come after the side-effects of // evaluating x and p(). emit := func(fn *Function) Value { return emitFieldSelection(fn, v, index, true, e.Sel) } return &lazyAddress{addr: emit, t: fld.Type(), expr: e.Sel} case *ast.IndexExpr: var x Value var et types.Type xt := fn.Pkg.typeOf(e.X) // Indexing doesn't need a core type, it only requires all types to be similar enough. For example, []int64 | // [5]int64 can be indexed. The element types do have to match though. terms, err := typeparams.NormalTerms(xt) if err != nil { panic(fmt.Sprintf("unexpected error: %s", err)) } isArrayLike := func() (types.Type, bool) { for _, term := range terms { arr, ok := term.Type().Underlying().(*types.Array) if ok { return arr.Elem(), true } } return nil, false } isSliceLike := func() (types.Type, bool) { for _, term := range terms { switch t := term.Type().Underlying().(type) { case *types.Slice: return t.Elem(), true case *types.Pointer: return t.Elem().Underlying().(*types.Array).Elem(), true } } return nil, false } if elem, ok := isArrayLike(); ok { // array x = b.addr(fn, e.X, escaping).address(fn) et = types.NewPointer(elem) } else if elem, ok := isSliceLike(); ok { // slice or *array x = b.expr(fn, e.X) et = types.NewPointer(elem) } else if t, ok := typeutil.CoreType(xt).Underlying().(*types.Map); ok { return &element{ m: b.expr(fn, e.X), k: emitConv(fn, b.expr(fn, e.Index), t.Key(), e.Index), t: t.Elem(), } } else { panic("unexpected container type in IndexExpr: " + t.String()) } // Due to the two phases of resolving AssignStmt, a panic from x[i] = p() // when x is nil or i is out-of-bounds is required to come after the // side-effects of evaluating x, i and p(). index := b.expr(fn, e.Index) emit := func(fn *Function) Value { v := &IndexAddr{ X: x, Index: index, } v.setType(et) return fn.emit(v, e) } return &lazyAddress{addr: emit, t: deref(et), expr: e} case *ast.StarExpr: return &address{addr: b.expr(fn, e.X), expr: e} } panic(fmt.Sprintf("unexpected address expression: %T", e)) } type store struct { lhs lvalue rhs Value source ast.Node // if debugRef is set no other fields will be set debugRef *DebugRef } type storebuf struct{ stores []store } func (sb *storebuf) store(lhs lvalue, rhs Value, source ast.Node) { sb.stores = append(sb.stores, store{lhs, rhs, source, nil}) } func (sb *storebuf) storeDebugRef(ref *DebugRef) { sb.stores = append(sb.stores, store{debugRef: ref}) } func (sb *storebuf) emit(fn *Function) { for _, s := range sb.stores { if s.debugRef == nil { s.lhs.store(fn, s.rhs, s.source) } else { fn.emit(s.debugRef, nil) } } } // assign emits to fn code to initialize the lvalue loc with the value // of expression e. If isZero is true, assign assumes that loc holds // the zero value for its type. // // This is equivalent to loc.store(fn, b.expr(fn, e)), but may generate // better code in some cases, e.g., for composite literals in an // addressable location. // // If sb is not nil, assign generates code to evaluate expression e, but // not to update loc. Instead, the necessary stores are appended to the // storebuf sb so that they can be executed later. This allows correct // in-place update of existing variables when the RHS is a composite // literal that may reference parts of the LHS. func (b *builder) assign(fn *Function, loc lvalue, e ast.Expr, isZero bool, sb *storebuf, source ast.Node) { // Can we initialize it in place? if e, ok := unparen(e).(*ast.CompositeLit); ok { // A CompositeLit never evaluates to a pointer, // so if the type of the location is a pointer, // an &-operation is implied. if _, ok := loc.(blank); !ok { // avoid calling blank.typ() if isPointer(loc.typ()) { // Example input that hits this code: // // type S1 struct{ X int } // x := []*S1{ // {1}, // <-- & is implied // } // _ = x ptr := b.addr(fn, e, true).address(fn) // copy address if sb != nil { sb.store(loc, ptr, source) } else { loc.store(fn, ptr, source) } return } } if _, ok := loc.(*address); ok { if types.IsInterface(loc.typ()) && !typeparams.IsTypeParam(loc.typ()) { // e.g. var x interface{} = T{...} // Can't in-place initialize an interface value. // Fall back to copying. } else { // x = T{...} or x := T{...} addr := loc.address(fn) if sb != nil { b.compLit(fn, addr, e, isZero, sb) } else { var sb storebuf b.compLit(fn, addr, e, isZero, &sb) sb.emit(fn) } // Subtle: emit debug ref for aggregate types only; // slice and map are handled by store ops in compLit. switch typeutil.CoreType(loc.typ()).Underlying().(type) { case *types.Struct, *types.Array: if sb != nil { // Make sure we don't emit DebugRefs before the store has actually occurred if ref := makeDebugRef(fn, e, addr, true); ref != nil { sb.storeDebugRef(ref) } } else { emitDebugRef(fn, e, addr, true) } } return } } } // simple case: just copy rhs := b.expr(fn, e) if sb != nil { sb.store(loc, rhs, source) } else { loc.store(fn, rhs, source) } } // expr lowers a single-result expression e to IR form, emitting code // to fn and returning the Value defined by the expression. func (b *builder) expr(fn *Function, e ast.Expr) Value { e = unparen(e) tv := fn.Pkg.info.Types[e] // Is expression a constant? if tv.Value != nil { return emitConst(fn, NewConst(tv.Value, tv.Type, e)) } var v Value if tv.Addressable() { // Prefer pointer arithmetic ({Index,Field}Addr) followed // by Load over subelement extraction (e.g. Index, Field), // to avoid large copies. v = b.addr(fn, e, false).load(fn, e) } else { v = b.expr0(fn, e, tv) } if fn.debugInfo() { emitDebugRef(fn, e, v, false) } return v } func (b *builder) expr0(fn *Function, e ast.Expr, tv types.TypeAndValue) Value { switch e := e.(type) { case *ast.BasicLit: panic("non-constant BasicLit") // unreachable case *ast.FuncLit: fn2 := &Function{ name: fmt.Sprintf("%s$%d", fn.Name(), 1+len(fn.AnonFuncs)), Signature: fn.Pkg.typeOf(e.Type).Underlying().(*types.Signature), parent: fn, Pkg: fn.Pkg, Prog: fn.Prog, functionBody: new(functionBody), goversion: fn.goversion, // share the parent's goversion } fn2.uniq = fn.uniq // start from parent's unique values fn2.source = e fn.AnonFuncs = append(fn.AnonFuncs, fn2) fn2.initHTML(b.printFunc) b.buildFunction(fn2) fn.uniq = fn2.uniq // resume after anon's unique values if fn2.FreeVars == nil { return fn2 } v := &MakeClosure{Fn: fn2} v.setType(tv.Type) for _, fv := range fn2.FreeVars { v.Bindings = append(v.Bindings, fv.outer) fv.outer = nil } return fn.emit(v, e) case *ast.TypeAssertExpr: // single-result form only return emitTypeAssert(fn, b.expr(fn, e.X), tv.Type, e) case *ast.CallExpr: if fn.Pkg.info.Types[e.Fun].IsType() { // Explicit type conversion, e.g. string(x) or big.Int(x) x := b.expr(fn, e.Args[0]) y := emitConv(fn, x, tv.Type, e) return y } // Call to "intrinsic" built-ins, e.g. new, make, panic. if id, ok := unparen(e.Fun).(*ast.Ident); ok { if obj, ok := fn.Pkg.info.Uses[id].(*types.Builtin); ok { if v := b.builtin(fn, obj, e.Args, tv.Type, e); v != nil { return v } } } // Regular function call. var v Call b.setCall(fn, e, &v.Call) v.setType(tv.Type) return fn.emit(&v, e) case *ast.UnaryExpr: switch e.Op { case token.AND: // &X --- potentially escaping. addr := b.addr(fn, e.X, true) if _, ok := unparen(e.X).(*ast.StarExpr); ok { // &*p must panic if p is nil (https://golang.org/s/go12nil). // For simplicity, we'll just (suboptimally) rely // on the side effects of a load. // TODO(adonovan): emit dedicated nilcheck. addr.load(fn, e) } return addr.address(fn) case token.ADD: return b.expr(fn, e.X) case token.NOT, token.SUB, token.XOR: // ! <- - ^ v := &UnOp{ Op: e.Op, X: b.expr(fn, e.X), } v.setType(tv.Type) return fn.emit(v, e) case token.ARROW: return emitRecv(fn, b.expr(fn, e.X), false, tv.Type, e) default: panic(e.Op) } case *ast.BinaryExpr: switch e.Op { case token.LAND, token.LOR: return b.logicalBinop(fn, e) case token.SHL, token.SHR: fallthrough case token.ADD, token.SUB, token.MUL, token.QUO, token.REM, token.AND, token.OR, token.XOR, token.AND_NOT: return emitArith(fn, e.Op, b.expr(fn, e.X), b.expr(fn, e.Y), tv.Type, e) case token.EQL, token.NEQ, token.GTR, token.LSS, token.LEQ, token.GEQ: cmp := emitCompare(fn, e.Op, b.expr(fn, e.X), b.expr(fn, e.Y), e) // The type of x==y may be UntypedBool. return emitConv(fn, cmp, types.Default(tv.Type), e) default: panic("illegal op in BinaryExpr: " + e.Op.String()) } case *ast.SliceExpr: var x Value if core := typeutil.CoreType(fn.Pkg.typeOf(e.X)); core != nil { switch core.Underlying().(type) { case *types.Array: // Potentially escaping. x = b.addr(fn, e.X, true).address(fn) case *types.Basic, *types.Slice, *types.Pointer: // *array x = b.expr(fn, e.X) default: panic("unreachable") } } else { // We're indexing a string | []byte. Note that other combinations such as []byte | [4]byte are currently not // allowed by the language. x = b.expr(fn, e.X) } var low, high, max Value if e.Low != nil { low = b.expr(fn, e.Low) } if e.High != nil { high = b.expr(fn, e.High) } if e.Slice3 { max = b.expr(fn, e.Max) } v := &Slice{ X: x, Low: low, High: high, Max: max, } v.setType(tv.Type) return fn.emit(v, e) case *ast.Ident: obj := fn.Pkg.info.Uses[e] // Universal built-in or nil? switch obj := obj.(type) { case *types.Builtin: return &Builtin{name: obj.Name(), sig: tv.Type.(*types.Signature)} case *types.Nil: return emitConst(fn, nilConst(tv.Type, e)) } // Package-level func or var? if v := fn.Prog.packageLevelValue(obj); v != nil { if _, ok := obj.(*types.Var); ok { return emitLoad(fn, v, e) // var (address) } if instance, ok := fn.Pkg.info.Instances[e]; ok { // Instantiated generic function return makeInstance(fn.Prog, v.(*Function), instance.Type.(*types.Signature), instance.TypeArgs) } return v // (func) } // Local var. return emitLoad(fn, fn.lookup(obj.(*types.Var), false), e) // var (address) case *ast.SelectorExpr: sel, ok := fn.Pkg.info.Selections[e] if !ok { // builtin unsafe.{Add,Slice} if obj, ok := fn.Pkg.info.Uses[e.Sel].(*types.Builtin); ok { return &Builtin{name: "Unsafe" + obj.Name(), sig: tv.Type.(*types.Signature)} } // qualified identifier return b.expr(fn, e.Sel) } switch sel.Kind() { case types.MethodExpr: // (*T).f or T.f, the method f from the method-set of type T. // The result is a "thunk". return emitConv(fn, makeThunk(fn.Prog, sel), tv.Type, e) case types.MethodVal: // e.f where e is an expression and f is a method. // The result is a "bound". obj := sel.Obj().(*types.Func) rt := recvType(obj) wantAddr := isPointer(rt) escaping := true v := b.receiver(fn, e.X, wantAddr, escaping, sel, e) if types.IsInterface(rt) { // If v has interface type I, // we must emit a check that v is non-nil. // We use: typeassert v.(I). emitTypeAssert(fn, v, rt, e) } c := &MakeClosure{ Fn: makeBound(fn.Prog, obj), Bindings: []Value{v}, } c.source = e.Sel c.setType(tv.Type) return fn.emit(c, e) case types.FieldVal: indices := sel.Index() last := len(indices) - 1 v := b.expr(fn, e.X) v = emitImplicitSelections(fn, v, indices[:last], e) v = emitFieldSelection(fn, v, indices[last], false, e.Sel) return v } panic("unexpected expression-relative selector") case *ast.IndexExpr: // IndexExpr might either be an actual indexing operation, or an instantiation xt := fn.Pkg.typeOf(e.X) terms, err := typeparams.NormalTerms(xt) if err != nil { panic(fmt.Sprintf("unexpected error: %s", err)) } isNonAddressableIndexable := func() (types.Type, bool) { for _, term := range terms { switch t := term.Type().Underlying().(type) { case *types.Array: return t.Elem(), true case *types.Basic: // a string return types.Universe.Lookup("byte").Type(), true } } return nil, false } isAddressableIndexable := func() (types.Type, bool) { for _, term := range terms { switch t := term.Type().Underlying().(type) { case *types.Slice: return t.Elem(), true case *types.Pointer: return t.Elem().Underlying().(*types.Array).Elem(), true } } return nil, false } if elem, ok := isNonAddressableIndexable(); ok { // At least one of the types is non-addressable v := &Index{ X: b.expr(fn, e.X), Index: b.expr(fn, e.Index), } v.setType(elem) return fn.emit(v, e) } else if _, ok := isAddressableIndexable(); ok { // All types are addressable (otherwise the previous branch would've fired) return b.addr(fn, e, false).load(fn, e) } else if t, ok := typeutil.CoreType(xt).Underlying().(*types.Map); ok { // Maps are not addressable. v := &MapLookup{ X: b.expr(fn, e.X), Index: emitConv(fn, b.expr(fn, e.Index), t.Key(), e.Index), } v.setType(t.Elem()) return fn.emit(v, e) } else if _, ok := xt.Underlying().(*types.Signature); ok { // Instantiating a generic function return b.expr(fn, e.X) } else { panic("unexpected container type in IndexExpr: " + t.String()) } case *ast.IndexListExpr: // Instantiating a generic function return b.expr(fn, e.X) case *ast.CompositeLit, *ast.StarExpr: // Addressable types (lvalues) return b.addr(fn, e, false).load(fn, e) } panic(fmt.Sprintf("unexpected expr: %T", e)) } // stmtList emits to fn code for all statements in list. func (b *builder) stmtList(fn *Function, list []ast.Stmt) { for _, s := range list { b.stmt(fn, s) } } // receiver emits to fn code for expression e in the "receiver" // position of selection e.f (where f may be a field or a method) and // returns the effective receiver after applying the implicit field // selections of sel. // // wantAddr requests that the result is an an address. If // !sel.Indirect(), this may require that e be built in addr() mode; it // must thus be addressable. // // escaping is defined as per builder.addr(). func (b *builder) receiver(fn *Function, e ast.Expr, wantAddr, escaping bool, sel *types.Selection, source ast.Node) Value { var v Value if wantAddr && !sel.Indirect() && !isPointer(fn.Pkg.typeOf(e)) { v = b.addr(fn, e, escaping).address(fn) } else { v = b.expr(fn, e) } last := len(sel.Index()) - 1 v = emitImplicitSelections(fn, v, sel.Index()[:last], source) if !wantAddr && isPointer(v.Type()) { v = emitLoad(fn, v, e) } return v } // setCallFunc populates the function parts of a CallCommon structure // (Func, Method, Recv, Args[0]) based on the kind of invocation // occurring in e. func (b *builder) setCallFunc(fn *Function, e *ast.CallExpr, c *CallCommon) { // Is this a method call? if selector, ok := unparen(e.Fun).(*ast.SelectorExpr); ok { sel, ok := fn.Pkg.info.Selections[selector] if ok && sel.Kind() == types.MethodVal { obj := sel.Obj().(*types.Func) recv := recvType(obj) wantAddr := isPointer(recv) escaping := true v := b.receiver(fn, selector.X, wantAddr, escaping, sel, selector) if types.IsInterface(recv) { // Invoke-mode call. // Methods in interfaces cannot have their own type parameters, so we needn't do anything for type // parameters. c.Value = v c.Method = obj } else { // "Call"-mode call. // declaredFunc takes care of creating wrappers for functions with type parameters. c.Value = fn.Prog.declaredFunc(obj) c.Args = append(c.Args, v) } return } // sel.Kind()==MethodExpr indicates T.f() or (*T).f(): // a statically dispatched call to the method f in the // method-set of T or *T. T may be an interface. // // e.Fun would evaluate to a concrete method, interface // wrapper function, or promotion wrapper. // // For now, we evaluate it in the usual way. // // TODO(adonovan): opt: inline expr() here, to make the // call static and to avoid generation of wrappers. // It's somewhat tricky as it may consume the first // actual parameter if the call is "invoke" mode. // // Examples: // type T struct{}; func (T) f() {} // "call" mode // type T interface { f() } // "invoke" mode // // type S struct{ T } // // var s S // S.f(s) // (*S).f(&s) // // Suggested approach: // - consume the first actual parameter expression // and build it with b.expr(). // - apply implicit field selections. // - use MethodVal logic to populate fields of c. } // Evaluate the function operand in the usual way. // // Code in expr takes care of creating wrappers for functions with type parameters. c.Value = b.expr(fn, e.Fun) } // emitCallArgs emits to f code for the actual parameters of call e to // a (possibly built-in) function of effective type sig. // The argument values are appended to args, which is then returned. func (b *builder) emitCallArgs(fn *Function, sig *types.Signature, e *ast.CallExpr, args []Value) []Value { // f(x, y, z...): pass slice z straight through. if e.Ellipsis != 0 { for i, arg := range e.Args { v := emitConv(fn, b.expr(fn, arg), sig.Params().At(i).Type(), arg) args = append(args, v) } return args } offset := len(args) // 1 if call has receiver, 0 otherwise // Evaluate actual parameter expressions. // // If this is a chained call of the form f(g()) where g has // multiple return values (MRV), they are flattened out into // args; a suffix of them may end up in a varargs slice. for _, arg := range e.Args { v := b.expr(fn, arg) if ttuple, ok := v.Type().(*types.Tuple); ok { // MRV chain for i, n := 0, ttuple.Len(); i < n; i++ { args = append(args, emitExtract(fn, v, i, arg)) } } else { args = append(args, v) } } // Actual->formal assignability conversions for normal parameters. np := sig.Params().Len() // number of normal parameters if sig.Variadic() { np-- } for i := 0; i < np; i++ { args[offset+i] = emitConv(fn, args[offset+i], sig.Params().At(i).Type(), args[offset+i].Source()) } // Actual->formal assignability conversions for variadic parameter, // and construction of slice. if sig.Variadic() { varargs := args[offset+np:] st := sig.Params().At(np).Type().(*types.Slice) vt := st.Elem() if len(varargs) == 0 { args = append(args, emitConst(fn, nilConst(st, nil))) } else { // Replace a suffix of args with a slice containing it. at := types.NewArray(vt, int64(len(varargs))) a := emitNew(fn, at, e, "varargs") a.source = e for i, arg := range varargs { iaddr := &IndexAddr{ X: a, Index: emitConst(fn, intConst(int64(i), nil)), } iaddr.setType(types.NewPointer(vt)) fn.emit(iaddr, e) emitStore(fn, iaddr, arg, arg.Source()) } s := &Slice{X: a} s.setType(st) args[offset+np] = fn.emit(s, args[offset+np].Source()) args = args[:offset+np+1] } } return args } // setCall emits to fn code to evaluate all the parameters of a function // call e, and populates *c with those values. func (b *builder) setCall(fn *Function, e *ast.CallExpr, c *CallCommon) { // First deal with the f(...) part and optional receiver. b.setCallFunc(fn, e, c) // Then append the other actual parameters. sig, _ := typeutil.CoreType(fn.Pkg.typeOf(e.Fun)).(*types.Signature) if sig == nil { panic(fmt.Sprintf("no signature for call of %s", e.Fun)) } c.Args = b.emitCallArgs(fn, sig, e, c.Args) } // assignOp emits to fn code to perform loc = val. func (b *builder) assignOp(fn *Function, loc lvalue, val Value, op token.Token, source ast.Node) { loc.store(fn, emitArith(fn, op, loc.load(fn, source), val, loc.typ(), source), source) } // localValueSpec emits to fn code to define all of the vars in the // function-local ValueSpec, spec. func (b *builder) localValueSpec(fn *Function, spec *ast.ValueSpec) { switch { case len(spec.Values) == len(spec.Names): // e.g. var x, y = 0, 1 // 1:1 assignment for i, id := range spec.Names { if !isBlankIdent(id) { emitLocalVar(fn, identVar(fn, id), id) } lval := b.addr(fn, id, false) // non-escaping b.assign(fn, lval, spec.Values[i], true, nil, spec) } case len(spec.Values) == 0: // e.g. var x, y int // Locals are implicitly zero-initialized. for _, id := range spec.Names { if !isBlankIdent(id) { lhs := emitLocalVar(fn, identVar(fn, id), id) if fn.debugInfo() { emitDebugRef(fn, id, lhs, true) } } } default: // e.g. var x, y = pos() tuple := b.exprN(fn, spec.Values[0]) for i, id := range spec.Names { if !isBlankIdent(id) { emitLocalVar(fn, identVar(fn, id), id) lhs := b.addr(fn, id, false) // non-escaping lhs.store(fn, emitExtract(fn, tuple, i, id), id) } } } } // assignStmt emits code to fn for a parallel assignment of rhss to lhss. // isDef is true if this is a short variable declaration (:=). // // Note the similarity with localValueSpec. func (b *builder) assignStmt(fn *Function, lhss, rhss []ast.Expr, isDef bool, source ast.Node) { // Side effects of all LHSs and RHSs must occur in left-to-right order. lvals := make([]lvalue, len(lhss)) isZero := make([]bool, len(lhss)) for i, lhs := range lhss { var lval lvalue = blank{} if !isBlankIdent(lhs) { if isDef { if obj, ok := fn.Pkg.info.Defs[lhs.(*ast.Ident)].(*types.Var); ok { emitLocalVar(fn, obj, lhs) isZero[i] = true } } lval = b.addr(fn, lhs, false) // non-escaping } lvals[i] = lval } if len(lhss) == len(rhss) { // Simple assignment: x = f() (!isDef) // Parallel assignment: x, y = f(), g() (!isDef) // or short var decl: x, y := f(), g() (isDef) // // In all cases, the RHSs may refer to the LHSs, // so we need a storebuf. var sb storebuf for i := range rhss { b.assign(fn, lvals[i], rhss[i], isZero[i], &sb, source) } sb.emit(fn) } else { // e.g. x, y = pos() tuple := b.exprN(fn, rhss[0]) emitDebugRef(fn, rhss[0], tuple, false) for i, lval := range lvals { lval.store(fn, emitExtract(fn, tuple, i, source), source) } } } // arrayLen returns the length of the array whose composite literal elements are elts. func (b *builder) arrayLen(fn *Function, elts []ast.Expr) int64 { var max int64 = -1 var i int64 = -1 for _, e := range elts { if kv, ok := e.(*ast.KeyValueExpr); ok { i = b.expr(fn, kv.Key).(*Const).Int64() } else { i++ } if i > max { max = i } } return max + 1 } // compLit emits to fn code to initialize a composite literal e at // address addr with type typ. // // Nested composite literals are recursively initialized in place // where possible. If isZero is true, compLit assumes that addr // holds the zero value for typ. // // Because the elements of a composite literal may refer to the // variables being updated, as in the second line below, // // x := T{a: 1} // x = T{a: x.a} // // all the reads must occur before all the writes. This is implicitly handled by the write buffering effected by // compositeElement and explicitly by the storebuf for when we don't use CompositeValue. // // A CompositeLit may have pointer type only in the recursive (nested) // case when the type name is implicit. e.g. in []*T{{}}, the inner // literal has type *T behaves like &T{}. // In that case, addr must hold a T, not a *T. func (b *builder) compLit(fn *Function, addr Value, e *ast.CompositeLit, isZero bool, sb *storebuf) { typ := deref(fn.Pkg.typeOf(e)) switch t := typeutil.CoreType(typ).(type) { case *types.Struct: lvalue := &address{addr: addr, expr: e} if len(e.Elts) == 0 { if !isZero { sb.store(lvalue, zeroValue(fn, deref(addr.Type()), e), e) } } else { v := &CompositeValue{ Values: make([]Value, t.NumFields()), } for i := 0; i < t.NumFields(); i++ { v.Values[i] = emitConst(fn, zeroConst(t.Field(i).Type(), e)) } v.setType(typ) for i, e := range e.Elts { fieldIndex := i if kv, ok := e.(*ast.KeyValueExpr); ok { fname := kv.Key.(*ast.Ident).Name for i, n := 0, t.NumFields(); i < n; i++ { sf := t.Field(i) if sf.Name() == fname { fieldIndex = i e = kv.Value break } } } ce := &compositeElement{ cv: v, idx: fieldIndex, t: t.Field(fieldIndex).Type(), expr: e, } b.assign(fn, ce, e, isZero, sb, e) v.Bitmap.SetBit(&v.Bitmap, fieldIndex, 1) v.NumSet++ } fn.emit(v, e) sb.store(lvalue, v, e) } case *types.Array, *types.Slice: var at *types.Array var array Value switch t := t.(type) { case *types.Slice: at = types.NewArray(t.Elem(), b.arrayLen(fn, e.Elts)) array = emitNew(fn, at, e, "slicelit") case *types.Array: at = t array = addr } var final Value if len(e.Elts) == 0 { if !isZero { zc := emitConst(fn, zeroConst(at, e)) final = zc } } else { if at.Len() == int64(len(e.Elts)) { // The literal specifies all elements, so we can use a composite value v := &CompositeValue{ Values: make([]Value, at.Len()), } zc := emitConst(fn, zeroConst(at.Elem(), e)) for i := range v.Values { v.Values[i] = zc } v.setType(at) var idx *Const for _, e := range e.Elts { if kv, ok := e.(*ast.KeyValueExpr); ok { idx = b.expr(fn, kv.Key).(*Const) e = kv.Value } else { var idxval int64 if idx != nil { idxval = idx.Int64() + 1 } idx = emitConst(fn, intConst(idxval, e)).(*Const) } iaddr := &compositeElement{ cv: v, idx: int(idx.Int64()), t: at.Elem(), expr: e, } b.assign(fn, iaddr, e, true, sb, e) v.Bitmap.SetBit(&v.Bitmap, int(idx.Int64()), 1) v.NumSet++ } final = v fn.emit(v, e) } else { // Not all elements are specified. Populate the array with a series of stores, to guard against literals // like []int{1<<62: 1}. if !isZero { // memclear sb.store(&address{array, nil}, zeroValue(fn, deref(array.Type()), e), e) } var idx *Const for _, e := range e.Elts { if kv, ok := e.(*ast.KeyValueExpr); ok { idx = b.expr(fn, kv.Key).(*Const) e = kv.Value } else { var idxval int64 if idx != nil { idxval = idx.Int64() + 1 } idx = emitConst(fn, intConst(idxval, e)).(*Const) } iaddr := &IndexAddr{ X: array, Index: idx, } iaddr.setType(types.NewPointer(at.Elem())) fn.emit(iaddr, e) if t != at { // slice // backing array is unaliased => storebuf not needed. b.assign(fn, &address{addr: iaddr, expr: e}, e, true, nil, e) } else { b.assign(fn, &address{addr: iaddr, expr: e}, e, true, sb, e) } } } } if t != at { // slice if final != nil { sb.store(&address{addr: array}, final, e) } s := &Slice{X: array} s.setType(typ) sb.store(&address{addr: addr, expr: e}, fn.emit(s, e), e) } else if final != nil { sb.store(&address{addr: array, expr: e}, final, e) } case *types.Map: m := &MakeMap{Reserve: emitConst(fn, intConst(int64(len(e.Elts)), e))} m.setType(typ) fn.emit(m, e) for _, e := range e.Elts { e := e.(*ast.KeyValueExpr) // If a key expression in a map literal is itself a // composite literal, the type may be omitted. // For example: // map[*struct{}]bool{{}: true} // An &-operation may be implied: // map[*struct{}]bool{&struct{}{}: true} var key Value if _, ok := unparen(e.Key).(*ast.CompositeLit); ok && isPointer(t.Key()) { // A CompositeLit never evaluates to a pointer, // so if the type of the location is a pointer, // an &-operation is implied. key = b.addr(fn, e.Key, true).address(fn) } else { key = b.expr(fn, e.Key) } loc := element{ m: m, k: emitConv(fn, key, t.Key(), e), t: t.Elem(), } // We call assign() only because it takes care // of any &-operation required in the recursive // case, e.g., // map[int]*struct{}{0: {}} implies &struct{}{}. // In-place update is of course impossible, // and no storebuf is needed. b.assign(fn, &loc, e.Value, true, nil, e) } sb.store(&address{addr: addr, expr: e}, m, e) default: panic("unexpected CompositeLit type: " + t.String()) } } func (b *builder) switchStmt(fn *Function, s *ast.SwitchStmt, label *lblock) { if s.Tag == nil { b.switchStmtDynamic(fn, s, label) return } dynamic := false for _, iclause := range s.Body.List { clause := iclause.(*ast.CaseClause) for _, cond := range clause.List { if fn.Pkg.info.Types[unparen(cond)].Value == nil { dynamic = true break } } } if dynamic { b.switchStmtDynamic(fn, s, label) return } if s.Init != nil { b.stmt(fn, s.Init) } entry := fn.currentBlock tag := b.expr(fn, s.Tag) heads := make([]*BasicBlock, 0, len(s.Body.List)) bodies := make([]*BasicBlock, len(s.Body.List)) conds := make([]Value, 0, len(s.Body.List)) hasDefault := false done := fn.newBasicBlock("switch.done") if label != nil { label._break = done } for i, stmt := range s.Body.List { body := fn.newBasicBlock(fmt.Sprintf("switch.body.%d", i)) bodies[i] = body cas := stmt.(*ast.CaseClause) if cas.List == nil { // default branch hasDefault = true head := fn.newBasicBlock(fmt.Sprintf("switch.head.%d", i)) conds = append(conds, nil) heads = append(heads, head) fn.currentBlock = head emitJump(fn, body, cas) } for j, cond := range stmt.(*ast.CaseClause).List { fn.currentBlock = entry head := fn.newBasicBlock(fmt.Sprintf("switch.head.%d.%d", i, j)) conds = append(conds, b.expr(fn, cond)) heads = append(heads, head) fn.currentBlock = head emitJump(fn, body, cond) } } for i, stmt := range s.Body.List { clause := stmt.(*ast.CaseClause) body := bodies[i] fn.currentBlock = body fallthru := done if i+1 < len(bodies) { fallthru = bodies[i+1] } fn.targets = &targets{ tail: fn.targets, _break: done, _fallthrough: fallthru, } b.stmtList(fn, clause.Body) fn.targets = fn.targets.tail emitJump(fn, done, stmt) } if !hasDefault { head := fn.newBasicBlock("switch.head.implicit-default") body := fn.newBasicBlock("switch.body.implicit-default") fn.currentBlock = head emitJump(fn, body, s) fn.currentBlock = body emitJump(fn, done, s) heads = append(heads, head) conds = append(conds, nil) } if len(heads) != len(conds) { panic(fmt.Sprintf("internal error: %d heads for %d conds", len(heads), len(conds))) } for _, head := range heads { addEdge(entry, head) } fn.currentBlock = entry entry.emit(&ConstantSwitch{ Tag: tag, Conds: conds, }, s) fn.currentBlock = done } // switchStmt emits to fn code for the switch statement s, optionally // labelled by label. func (b *builder) switchStmtDynamic(fn *Function, s *ast.SwitchStmt, label *lblock) { // We treat SwitchStmt like a sequential if-else chain. // Multiway dispatch can be recovered later by irutil.Switches() // to those cases that are free of side effects. if s.Init != nil { b.stmt(fn, s.Init) } kTrue := emitConst(fn, NewConst(constant.MakeBool(true), tBool, nil)) var tagv Value = kTrue var tagSource ast.Node = s if s.Tag != nil { tagv = b.expr(fn, s.Tag) tagSource = s.Tag } // lifting only considers loads and stores, but we want different // sigma nodes for the different comparisons. use a temporary and // load it in every branch. tag := emitLocal(fn, tagv.Type(), tagSource, "switch.value") tag.comment = "switch.tag" emitStore(fn, tag, tagv, tagSource) done := fn.newBasicBlock("switch.done") if label != nil { label._break = done } // We pull the default case (if present) down to the end. // But each fallthrough label must point to the next // body block in source order, so we preallocate a // body block (fallthru) for the next case. // Unfortunately this makes for a confusing block order. var dfltBody *[]ast.Stmt var dfltFallthrough *BasicBlock var fallthru, dfltBlock *BasicBlock ncases := len(s.Body.List) for i, clause := range s.Body.List { body := fallthru if body == nil { body = fn.newBasicBlock("switch.body") // first case only } // Preallocate body block for the next case. fallthru = done if i+1 < ncases { fallthru = fn.newBasicBlock("switch.body") } cc := clause.(*ast.CaseClause) if cc.List == nil { // Default case. dfltBody = &cc.Body dfltFallthrough = fallthru dfltBlock = body continue } var nextCond *BasicBlock for _, cond := range cc.List { nextCond = fn.newBasicBlock("switch.next") if tagv == kTrue { // emit a proper if/else chain instead of a comparison // of a value against true. // // NOTE(dh): adonovan had a todo saying "don't forget // conversions though". As far as I can tell, there // aren't any conversions that we need to take care of // here. `case bool(a) && bool(b)` as well as `case // bool(a && b)` are being taken care of by b.cond, // and `case a` where a is not of type bool is // invalid. b.cond(fn, cond, body, nextCond) } else { cond := emitCompare(fn, token.EQL, emitLoad(fn, tag, cond), b.expr(fn, cond), cond) emitIf(fn, cond, body, nextCond, cond.Source()) } fn.currentBlock = nextCond } fn.currentBlock = body fn.targets = &targets{ tail: fn.targets, _break: done, _fallthrough: fallthru, } b.stmtList(fn, cc.Body) fn.targets = fn.targets.tail emitJump(fn, done, s) fn.currentBlock = nextCond } if dfltBlock != nil { // The lack of a Source for the jump doesn't matter, block // fusing will get rid of the jump later. emitJump(fn, dfltBlock, s) fn.currentBlock = dfltBlock fn.targets = &targets{ tail: fn.targets, _break: done, _fallthrough: dfltFallthrough, } b.stmtList(fn, *dfltBody) fn.targets = fn.targets.tail } emitJump(fn, done, s) fn.currentBlock = done } func (b *builder) typeSwitchStmt(fn *Function, s *ast.TypeSwitchStmt, label *lblock) { if s.Init != nil { b.stmt(fn, s.Init) } var tag Value switch e := s.Assign.(type) { case *ast.ExprStmt: // x.(type) tag = b.expr(fn, unparen(e.X).(*ast.TypeAssertExpr).X) case *ast.AssignStmt: // y := x.(type) tag = b.expr(fn, unparen(e.Rhs[0]).(*ast.TypeAssertExpr).X) default: panic("unreachable") } tagPtr := emitLocal(fn, tag.Type(), tag.Source(), "") emitStore(fn, tagPtr, tag, tag.Source()) // +1 in case there's no explicit default case heads := make([]*BasicBlock, 0, len(s.Body.List)+1) entry := fn.currentBlock done := fn.newBasicBlock("done") if label != nil { label._break = done } // set up type switch and constant switch, populate their conditions tswtch := &TypeSwitch{ Tag: emitLoad(fn, tagPtr, tag.Source()), Conds: make([]types.Type, 0, len(s.Body.List)+1), } cswtch := &ConstantSwitch{ Conds: make([]Value, 0, len(s.Body.List)+1), } rets := make([]types.Type, 0, len(s.Body.List)+1) index := 0 var default_ *ast.CaseClause for _, clause := range s.Body.List { cc := clause.(*ast.CaseClause) if obj, ok := fn.Pkg.info.Implicits[cc].(*types.Var); ok { emitLocalVar(fn, obj, cc) } if cc.List == nil { // default case default_ = cc } else { for _, expr := range cc.List { tswtch.Conds = append(tswtch.Conds, fn.Pkg.typeOf(expr)) cswtch.Conds = append(cswtch.Conds, emitConst(fn, intConst(int64(index), expr))) index++ } if len(cc.List) == 1 { rets = append(rets, fn.Pkg.typeOf(cc.List[0])) } else { for range cc.List { rets = append(rets, tag.Type()) } } } } // default branch rets = append(rets, tag.Type()) var vars []*types.Var vars = append(vars, varIndex) for _, typ := range rets { vars = append(vars, anonVar(typ)) } tswtch.setType(types.NewTuple(vars...)) // default branch fn.currentBlock = entry fn.emit(tswtch, s) cswtch.Conds = append(cswtch.Conds, emitConst(fn, intConst(int64(-1), nil))) // in theory we should add a local and stores/loads for tswtch, to // generate sigma nodes in the branches. however, there isn't any // useful information we could possibly attach to it. cswtch.Tag = emitExtract(fn, tswtch, 0, s) fn.emit(cswtch, s) // build heads and bodies index = 0 for _, clause := range s.Body.List { cc := clause.(*ast.CaseClause) if cc.List == nil { continue } body := fn.newBasicBlock("typeswitch.body") for _, expr := range cc.List { head := fn.newBasicBlock("typeswitch.head") heads = append(heads, head) fn.currentBlock = head if obj, ok := fn.Pkg.info.Implicits[cc].(*types.Var); ok { // In a switch y := x.(type), each case clause // implicitly declares a distinct object y. // In a single-type case, y has that type. // In multi-type cases, 'case nil' and default, // y has the same type as the interface operand. l := fn.vars[obj] if rets[index] == tUntypedNil { emitStore(fn, l, emitConst(fn, nilConst(tswtch.Tag.Type(), nil)), s.Assign) } else { x := emitExtract(fn, tswtch, index+1, s.Assign) emitStore(fn, l, x, nil) } } emitJump(fn, body, expr) index++ } fn.currentBlock = body fn.targets = &targets{ tail: fn.targets, _break: done, } b.stmtList(fn, cc.Body) fn.targets = fn.targets.tail emitJump(fn, done, clause) } if default_ == nil { // implicit default heads = append(heads, done) } else { body := fn.newBasicBlock("typeswitch.default") heads = append(heads, body) fn.currentBlock = body fn.targets = &targets{ tail: fn.targets, _break: done, } if obj, ok := fn.Pkg.info.Implicits[default_].(*types.Var); ok { l := fn.vars[obj] x := emitExtract(fn, tswtch, index+1, s.Assign) emitStore(fn, l, x, s) } b.stmtList(fn, default_.Body) fn.targets = fn.targets.tail emitJump(fn, done, s) } fn.currentBlock = entry for _, head := range heads { addEdge(entry, head) } fn.currentBlock = done } // selectStmt emits to fn code for the select statement s, optionally // labelled by label. func (b *builder) selectStmt(fn *Function, s *ast.SelectStmt, label *lblock) (noreturn bool) { if len(s.Body.List) == 0 { instr := &Select{Blocking: true} instr.setType(types.NewTuple(varIndex, varOk)) fn.emit(instr, s) fn.emit(new(Unreachable), s) addEdge(fn.currentBlock, fn.Exit) return true } // A blocking select of a single case degenerates to a // simple send or receive. // TODO(adonovan): opt: is this optimization worth its weight? if len(s.Body.List) == 1 { clause := s.Body.List[0].(*ast.CommClause) if clause.Comm != nil { b.stmt(fn, clause.Comm) done := fn.newBasicBlock("select.done") if label != nil { label._break = done } fn.targets = &targets{ tail: fn.targets, _break: done, } b.stmtList(fn, clause.Body) fn.targets = fn.targets.tail emitJump(fn, done, clause) fn.currentBlock = done return false } } // First evaluate all channels in all cases, and find // the directions of each state. var states []*SelectState blocking := true debugInfo := fn.debugInfo() for _, clause := range s.Body.List { var st *SelectState switch comm := clause.(*ast.CommClause).Comm.(type) { case nil: // default case blocking = false continue case *ast.SendStmt: // ch<- i ch := b.expr(fn, comm.Chan) st = &SelectState{ Dir: types.SendOnly, Chan: ch, Send: emitConv(fn, b.expr(fn, comm.Value), typeutil.CoreType(ch.Type()).Underlying().(*types.Chan).Elem(), comm), Pos: comm.Arrow, } if debugInfo { st.DebugNode = comm } case *ast.AssignStmt: // x := <-ch recv := unparen(comm.Rhs[0]).(*ast.UnaryExpr) st = &SelectState{ Dir: types.RecvOnly, Chan: b.expr(fn, recv.X), Pos: recv.OpPos, } if debugInfo { st.DebugNode = recv } case *ast.ExprStmt: // <-ch recv := unparen(comm.X).(*ast.UnaryExpr) st = &SelectState{ Dir: types.RecvOnly, Chan: b.expr(fn, recv.X), Pos: recv.OpPos, } if debugInfo { st.DebugNode = recv } } states = append(states, st) } // We dispatch on the (fair) result of Select using a // switch on the returned index. sel := &Select{ States: states, Blocking: blocking, } sel.source = s var vars []*types.Var vars = append(vars, varIndex, varOk) for _, st := range states { if st.Dir == types.RecvOnly { tElem := typeutil.CoreType(st.Chan.Type()).Underlying().(*types.Chan).Elem() vars = append(vars, anonVar(tElem)) } } sel.setType(types.NewTuple(vars...)) fn.emit(sel, s) idx := emitExtract(fn, sel, 0, s) done := fn.newBasicBlock("select.done") if label != nil { label._break = done } entry := fn.currentBlock swtch := &ConstantSwitch{ Tag: idx, // one condition per case Conds: make([]Value, 0, len(s.Body.List)+1), } // note that we don't need heads; a select case can only have a single condition var bodies []*BasicBlock state := 0 r := 2 // index in 'sel' tuple of value; increments if st.Dir==RECV for _, cc := range s.Body.List { clause := cc.(*ast.CommClause) if clause.Comm == nil { body := fn.newBasicBlock("select.default") fn.currentBlock = body bodies = append(bodies, body) fn.targets = &targets{ tail: fn.targets, _break: done, } b.stmtList(fn, clause.Body) emitJump(fn, done, s) fn.targets = fn.targets.tail swtch.Conds = append(swtch.Conds, emitConst(fn, intConst(-1, nil))) continue } swtch.Conds = append(swtch.Conds, emitConst(fn, intConst(int64(state), nil))) body := fn.newBasicBlock("select.body") fn.currentBlock = body bodies = append(bodies, body) fn.targets = &targets{ tail: fn.targets, _break: done, } switch comm := clause.Comm.(type) { case *ast.ExprStmt: // <-ch if debugInfo { v := emitExtract(fn, sel, r, comm) emitDebugRef(fn, states[state].DebugNode.(ast.Expr), v, false) } r++ case *ast.AssignStmt: // x := <-states[state].Chan if comm.Tok == token.DEFINE { id := comm.Lhs[0].(*ast.Ident) emitLocalVar(fn, identVar(fn, id), id) } x := b.addr(fn, comm.Lhs[0], false) // non-escaping v := emitExtract(fn, sel, r, comm) if debugInfo { emitDebugRef(fn, states[state].DebugNode.(ast.Expr), v, false) } x.store(fn, v, comm) if len(comm.Lhs) == 2 { // x, ok := ... if comm.Tok == token.DEFINE { id := comm.Lhs[1].(*ast.Ident) emitLocalVar(fn, identVar(fn, id), id) } ok := b.addr(fn, comm.Lhs[1], false) // non-escaping ok.store(fn, emitExtract(fn, sel, 1, comm), comm) } r++ } b.stmtList(fn, clause.Body) fn.targets = fn.targets.tail emitJump(fn, done, s) state++ } fn.currentBlock = entry fn.emit(swtch, s) for _, body := range bodies { addEdge(entry, body) } fn.currentBlock = done return false } // forStmt emits to fn code for the for statement s, optionally // labelled by label. func (b *builder) forStmt(fn *Function, s *ast.ForStmt, label *lblock) { // Use forStmtGo122 instead if it applies. if s.Init != nil { if assign, ok := s.Init.(*ast.AssignStmt); ok && assign.Tok == token.DEFINE { if version.Compare(fn.goversion, "go1.22") >= 0 { b.forStmtGo122(fn, s, label) return } } } // ...init... // jump loop // loop: // if cond goto body else done // body: // ...body... // jump post // post: (target of continue) // ...post... // jump loop // done: (target of break) if s.Init != nil { b.stmt(fn, s.Init) } body := fn.newBasicBlock("for.body") done := fn.newBasicBlock("for.done") // target of 'break' loop := body // target of back-edge if s.Cond != nil { loop = fn.newBasicBlock("for.loop") } cont := loop // target of 'continue' if s.Post != nil { cont = fn.newBasicBlock("for.post") } if label != nil { label._break = done label._continue = cont } emitJump(fn, loop, s) fn.currentBlock = loop if loop != body { b.cond(fn, s.Cond, body, done) fn.currentBlock = body } fn.targets = &targets{ tail: fn.targets, _break: done, _continue: cont, } b.stmt(fn, s.Body) fn.targets = fn.targets.tail emitJump(fn, cont, s) if s.Post != nil { fn.currentBlock = cont b.stmt(fn, s.Post) emitJump(fn, loop, s) // back-edge } fn.currentBlock = done } // forStmtGo122 emits to fn code for the for statement s, optionally // labelled by label. s must define its variables. // // This allocates once per loop iteration. This is only correct in // GoVersions >= go1.22. func (b *builder) forStmtGo122(fn *Function, s *ast.ForStmt, label *lblock) { // i_outer = alloc[T] // *i_outer = ...init... // under objects[i] = i_outer // jump loop // loop: // i = phi [head: i_outer, loop: i_next] // ...cond... // under objects[i] = i // if cond goto body else done // body: // ...body... // under objects[i] = i (same as loop) // jump post // post: // tmp = *i // i_next = alloc[T] // *i_next = tmp // ...post... // under objects[i] = i_next // goto loop // done: init := s.Init.(*ast.AssignStmt) startingBlocks := len(fn.Blocks) pre := fn.currentBlock // current block before starting loop := fn.newBasicBlock("for.loop") // target of back-edge body := fn.newBasicBlock("for.body") post := fn.newBasicBlock("for.post") // target of 'continue' done := fn.newBasicBlock("for.done") // target of 'break' // For each of the n loop variables, we create five SSA values, // outer, phi, next, load, and store in pre, loop, and post. // There is no limit on n. type loopVar struct { obj *types.Var outer *Alloc phi *Phi load *Load next *Alloc store *Store } vars := make([]loopVar, len(init.Lhs)) for i, lhs := range init.Lhs { v := identVar(fn, lhs.(*ast.Ident)) fn.currentBlock = pre outer := emitLocal(fn, v.Type(), lhs, v.Name()) fn.currentBlock = loop phi := &Phi{} phi.comment = v.Name() phi.typ = outer.Type() fn.emit(phi, lhs) fn.currentBlock = post // If next is is local, it reuses the address and zeroes the old value so // load before allocating next. load := emitLoad(fn, phi, init) next := emitLocal(fn, v.Type(), lhs, v.Name()) store := emitStore(fn, next, load, s) phi.Edges = []Value{outer, next} // pre edge is emitted before post edge. vars[i] = loopVar{v, outer, phi, load, next, store} } // ...init... under fn.objects[v] = i_outer fn.currentBlock = pre for _, v := range vars { fn.vars[v.obj] = v.outer } const isDef = false // assign to already-allocated outers b.assignStmt(fn, init.Lhs, init.Rhs, isDef, s) if label != nil { label._break = done label._continue = post } emitJump(fn, loop, s) // ...cond... under fn.objects[v] = i fn.currentBlock = loop for _, v := range vars { fn.vars[v.obj] = v.phi } if s.Cond != nil { b.cond(fn, s.Cond, body, done) } else { emitJump(fn, body, s) } // ...body... under fn.objects[v] = i fn.currentBlock = body fn.targets = &targets{ tail: fn.targets, _break: done, _continue: post, } b.stmt(fn, s.Body) fn.targets = fn.targets.tail emitJump(fn, post, s) // ...post... under fn.objects[v] = i_next for _, v := range vars { fn.vars[v.obj] = v.next } fn.currentBlock = post if s.Post != nil { b.stmt(fn, s.Post) } emitJump(fn, loop, s) // back-edge fn.currentBlock = done // For each loop variable that does not escape, // (the common case), fuse its next cells into its // (local) outer cell as they have disjoint live ranges. // // It is sufficient to test whether i_next escapes, // because its Heap flag will be marked true if either // the cond or post expression causes i to escape // (because escape distributes over phi). var nlocals int for _, v := range vars { if !v.next.Heap { nlocals++ } } if nlocals > 0 { replace := make(map[Value]Value, 2*nlocals) dead := make(map[Instruction]bool, 4*nlocals) for _, v := range vars { if !v.next.Heap { replace[v.next] = v.outer replace[v.phi] = v.outer dead[v.phi], dead[v.next], dead[v.load], dead[v.store] = true, true, true, true } } // Replace all uses of i_next and phi with i_outer. // Referrers have not been built for fn yet so only update Instruction operands. // We need only look within the blocks added by the loop. var operands []*Value // recycle storage for _, b := range fn.Blocks[startingBlocks:] { for _, instr := range b.Instrs { operands = instr.Operands(operands[:0]) for _, ptr := range operands { k := *ptr if v := replace[k]; v != nil { *ptr = v } } } } // Remove instructions for phi, load, and store. // lift() will remove the unused i_next *Alloc. isDead := func(i Instruction) bool { return dead[i] } loop.Instrs = removeInstrsIf(loop.Instrs, isDead) post.Instrs = removeInstrsIf(post.Instrs, isDead) } } // rangeIndexed emits to fn the header for an integer-indexed loop // over array, *array or slice value x. // The v result is defined only if tv is non-nil. // forPos is the position of the "for" token. func (b *builder) rangeIndexed(fn *Function, x Value, tv types.Type, source ast.Node) (k, v Value, loop, done *BasicBlock) { // // length = len(x) // index = -1 // loop: (target of continue) // index++ // if index < length goto body else done // body: // k = index // v = x[index] // ...body... // jump loop // done: (target of break) // We store in an Alloc and load it on each iteration so that lifting produces the necessary σ nodes xAlloc := newVariable(fn, x.Type(), source) xAlloc.store(x) // Determine number of iterations. // // We store the length in an Alloc and load it on each iteration so that lifting produces the necessary σ nodes length := newVariable(fn, tInt, source) if arr, ok := typeutil.CoreType(deref(x.Type())).(*types.Array); ok { // For array or *array, the number of iterations is known statically thanks to the type. We avoid a data // dependence upon x, permitting later dead-code elimination if x is pure, static unrolling, etc. Ranging over a // nil *array may have >0 iterations. We still generate code for x, in case it has effects. // // We use the core type of x, even though the length of type parameters isn't constant as per the language // specification. Just because len(x) isn't constant doesn't mean we can't emit IR that takes advantage of a // known length. length.store(emitConst(fn, intConst(arr.Len(), nil))) } else { // length = len(x). var c Call c.Call.Value = makeLen(x.Type()) c.Call.Args = []Value{x} c.setType(tInt) length.store(fn.emit(&c, source)) } index := emitLocal(fn, tInt, source, "rangeindex") emitStore(fn, index, emitConst(fn, intConst(-1, nil)), source) loop = fn.newBasicBlock("rangeindex.loop") emitJump(fn, loop, source) fn.currentBlock = loop incr := &BinOp{ Op: token.ADD, X: emitLoad(fn, index, source), Y: emitConst(fn, intConst(1, nil)), } incr.setType(tInt) emitStore(fn, index, fn.emit(incr, source), source) body := fn.newBasicBlock("rangeindex.body") done = fn.newBasicBlock("rangeindex.done") emitIf(fn, emitCompare(fn, token.LSS, incr, length.load(), source), body, done, source) fn.currentBlock = body k = emitLoad(fn, index, source) if tv != nil { x := xAlloc.load() switch t := typeutil.CoreType(x.Type()).Underlying().(type) { case *types.Array: instr := &Index{ X: x, Index: k, } instr.setType(t.Elem()) v = fn.emit(instr, source) case *types.Pointer: // *array instr := &IndexAddr{ X: x, Index: k, } instr.setType(types.NewPointer(t.Elem().Underlying().(*types.Array).Elem())) v = emitLoad(fn, fn.emit(instr, source), source) case *types.Slice: instr := &IndexAddr{ X: x, Index: k, } instr.setType(types.NewPointer(t.Elem())) v = emitLoad(fn, fn.emit(instr, source), source) default: panic("rangeIndexed x:" + t.String()) } } return } // rangeIter emits to fn the header for a loop using // Range/Next/Extract to iterate over map or string value x. // tk and tv are the types of the key/value results k and v, or nil // if the respective component is not wanted. func (b *builder) rangeIter(fn *Function, x Value, tk, tv types.Type, source ast.Node) (k, v Value, loop, done *BasicBlock) { // // it = range x // loop: (target of continue) // okv = next it (ok, key, value) // ok = extract okv #0 // if ok goto body else done // body: // k = extract okv #1 // v = extract okv #2 // ...body... // jump loop // done: (target of break) // if tk == nil { tk = tInvalid } if tv == nil { tv = tInvalid } rng := &Range{X: x} rng.setType(typeutil.NewIterator(types.NewTuple( varOk, newVar("k", tk), newVar("v", tv), ))) it := newVariable(fn, rng.typ, source) it.store(fn.emit(rng, source)) loop = fn.newBasicBlock("rangeiter.loop") emitJump(fn, loop, source) fn.currentBlock = loop // Go doesn't currently allow ranging over string|[]byte, so isString is decidable. _, isString := typeutil.CoreType(x.Type()).Underlying().(*types.Basic) okvInstr := &Next{ Iter: it.load(), IsString: isString, } okvInstr.setType(rng.typ.(*typeutil.Iterator).Elem()) fn.emit(okvInstr, source) okv := newVariable(fn, okvInstr.Type(), source) okv.store(okvInstr) body := fn.newBasicBlock("rangeiter.body") done = fn.newBasicBlock("rangeiter.done") emitIf(fn, emitExtract(fn, okv.load(), 0, source), body, done, source) fn.currentBlock = body if tk != tInvalid { k = emitExtract(fn, okv.load(), 1, source) } if tv != tInvalid { v = emitExtract(fn, okv.load(), 2, source) } return } // rangeChan emits to fn the header for a loop that receives from // channel x until it fails. // tk is the channel's element type, or nil if the k result is // not wanted // pos is the position of the '=' or ':=' token. func (b *builder) rangeChan(fn *Function, x Value, tk types.Type, source ast.Node) (k Value, loop, done *BasicBlock) { // // loop: (target of continue) // ko = <-x (key, ok) // ok = extract ko #1 // if ok goto body else done // body: // k = extract ko #0 // ... // goto loop // done: (target of break) loop = fn.newBasicBlock("rangechan.loop") emitJump(fn, loop, source) fn.currentBlock = loop recv := emitRecv(fn, x, true, types.NewTuple(newVar("k", typeutil.CoreType(x.Type()).Underlying().(*types.Chan).Elem()), varOk), source) retv := newVariable(fn, recv.Type(), source) retv.store(recv) body := fn.newBasicBlock("rangechan.body") done = fn.newBasicBlock("rangechan.done") emitIf(fn, emitExtract(fn, retv.load(), 1, source), body, done, source) fn.currentBlock = body if tk != nil { k = emitExtract(fn, retv.load(), 0, source) } return } // rangeInt emits to fn the header for a range loop with an integer operand. // tk is the key value's type, or nil if the k result is not wanted. // pos is the position of the "for" token. func (b *builder) rangeInt(fn *Function, x Value, tk types.Type, source ast.Node) (k Value, loop, done *BasicBlock) { // // iter = 0 // if 0 < x goto body else done // loop: (target of continue) // iter++ // if iter < x goto body else done // body: // k = x // ...body... // jump loop // done: (target of break) if b, ok := x.Type().(*types.Basic); ok && b.Info()&types.IsUntyped != 0 { x = emitConv(fn, x, tInt, source) } T := x.Type() iter := emitLocal(fn, T, source, "rangeint.iter") // x may be unsigned. Avoid initializing x to -1. body := fn.newBasicBlock("rangeint.body") done = fn.newBasicBlock("rangeint.done") emitIf(fn, emitCompare(fn, token.LSS, emitConst(fn, zeroConst(T, source)), x, source), body, done, source) loop = fn.newBasicBlock("rangeint.loop") fn.currentBlock = loop incr := &BinOp{ Op: token.ADD, X: emitLoad(fn, iter, source), Y: emitConv(fn, emitConst(fn, intConst(1, source)), T, source), } incr.setType(T) emitStore(fn, iter, fn.emit(incr, source), source) emitIf(fn, emitCompare(fn, token.LSS, incr, x, source), body, done, source) fn.currentBlock = body if tk != nil { // Integer types (int, uint8, etc.) are named and // we know that k is assignable to x when tk != nil. // This implies tk and T are identical so no conversion is needed. k = emitLoad(fn, iter, source) } return } type variable struct { alloc *Alloc fn *Function source ast.Node } func newVariable(fn *Function, typ types.Type, source ast.Node) *variable { alloc := &Alloc{} alloc.setType(types.NewPointer(typ)) fn.emit(alloc, source) fn.Locals = append(fn.Locals, alloc) return &variable{ alloc: alloc, fn: fn, source: source, } } func (v *variable) store(sv Value) { emitStore(v.fn, v.alloc, sv, v.source) } func (v *variable) load() Value { return emitLoad(v.fn, v.alloc, v.source) } // rangeStmt emits to fn code for the range statement s, optionally // labelled by label. func (b *builder) rangeStmt(fn *Function, s *ast.RangeStmt, label *lblock, source ast.Node) { var tk, tv types.Type if s.Key != nil && !isBlankIdent(s.Key) { tk = fn.Pkg.typeOf(s.Key) } if s.Value != nil && !isBlankIdent(s.Value) { tv = fn.Pkg.typeOf(s.Value) } // create locals for s.Key and s.Value createVars := func() { // Unlike a short variable declaration, a RangeStmt // using := never redeclares an existing variable; it // always creates a new one. if tk != nil { id := s.Key.(*ast.Ident) emitLocalVar(fn, identVar(fn, id), id) } if tv != nil { id := s.Value.(*ast.Ident) emitLocalVar(fn, identVar(fn, id), id) } } afterGo122 := version.Compare(fn.goversion, "go1.22") >= 0 if s.Tok == token.DEFINE && !afterGo122 { // pre-go1.22: If iteration variables are defined (:=), this // occurs once outside the loop. createVars() } x := b.expr(fn, s.X) var k, v Value var loop, done *BasicBlock switch rt := typeutil.CoreType(x.Type()).Underlying().(type) { case *types.Slice, *types.Array, *types.Pointer: // *array k, v, loop, done = b.rangeIndexed(fn, x, tv, source) case *types.Chan: k, loop, done = b.rangeChan(fn, x, tk, source) case *types.Map: k, v, loop, done = b.rangeIter(fn, x, tk, tv, source) case *types.Basic: switch { case rt.Info()&types.IsString != 0: k, v, loop, done = b.rangeIter(fn, x, tk, tv, source) case rt.Info()&types.IsInteger != 0: k, loop, done = b.rangeInt(fn, x, tk, source) default: panic("Cannot range over basic type: " + rt.String()) } case *types.Signature: // Special case rewrite (fn.goversion >= go1.23): // for x := range f { ... } // into // f(func(x T) bool { ... }) b.rangeFunc(fn, x, tk, tv, s, label) return default: panic("Cannot range over: " + rt.String()) } if s.Tok == token.DEFINE && afterGo122 { // go1.22: If iteration variables are defined (:=), this occurs inside the loop. createVars() } // Evaluate both LHS expressions before we update either. var kl, vl lvalue if tk != nil { kl = b.addr(fn, s.Key, false) // non-escaping } if tv != nil { vl = b.addr(fn, s.Value, false) // non-escaping } if tk != nil { kl.store(fn, k, s) } if tv != nil { vl.store(fn, v, s) } if label != nil { label._break = done label._continue = loop } fn.targets = &targets{ tail: fn.targets, _break: done, _continue: loop, } b.stmt(fn, s.Body) fn.targets = fn.targets.tail emitJump(fn, loop, source) // back-edge fn.currentBlock = done } // rangeFunc emits to fn code for the range-over-func rng.Body of the iterator // function x, optionally labelled by label. It creates a new anonymous function // yield for rng and builds the function. func (b *builder) rangeFunc(fn *Function, x Value, tk, tv types.Type, rng *ast.RangeStmt, label *lblock) { // Consider the SSA code for the outermost range-over-func in fn: // // func fn(...) (ret R) { // ... // for k, v = range x { // ... // } // ... // } // // The code emitted into fn will look something like this. // // loop: // jump := READY // y := make closure yield [ret, deferstack, jump, k, v] // x(y) // switch jump { // [see resuming execution] // } // goto done // done: // ... // // where yield is a new synthetic yield function: // // func yield(_k tk, _v tv) bool // free variables: [ret, stack, jump, k, v] // { // entry: // if jump != READY then goto invalid else valid // invalid: // panic("iterator called when it is not in a ready state") // valid: // jump = BUSY // k = _k // v = _v // ... // cont: // jump = READY // return true // } // // Yield state: // // Each range loop has an associated jump variable that records // the state of the iterator. A yield function is initially // in a READY (0) and callable state. If the yield function is called // and is not in READY state, it panics. When it is called in a callable // state, it becomes BUSY. When execution reaches the end of the body // of the loop (or a continue statement targeting the loop is executed), // the yield function returns true and resumes being in a READY state. // After the iterator function x(y) returns, then if the yield function // is in a READY state, the yield enters the DONE state. // // Each lowered control statement (break X, continue X, goto Z, or return) // that exits the loop sets the variable to a unique positive EXIT value, // before returning false from the yield function. // // If the yield function returns abruptly due to a panic or GoExit, // it remains in a BUSY state. The generated code asserts that, after // the iterator call x(y) returns normally, the jump variable state // is DONE. // // Resuming execution: // // The code generated for the range statement checks the jump // variable to determine how to resume execution. // // switch jump { // case BUSY: panic("...") // case DONE: goto done // case READY: state = DONE; goto done // case 123: ... // action for exit 123. // case 456: ... // action for exit 456. // ... // } // // Forward goto statements within a yield are jumps to labels that // have not yet been traversed in fn. They may be in the Body of the // function. What we emit for these is: // // goto target // target: // ... // // We leave an unresolved exit in yield.exits to check at the end // of building yield if it encountered target in the body. If it // encountered target, no additional work is required. Otherwise, // the yield emits a new early exit in the basic block for target. // We expect that blockopt will fuse the early exit into the case // block later. The unresolved exit is then added to yield.parent.exits. loop := fn.newBasicBlock("rangefunc.loop") done := fn.newBasicBlock("rangefunc.done") // These are targets within y. fn.targets = &targets{ tail: fn.targets, _break: done, // _continue is within y. } if label != nil { label._break = done // _continue is within y } emitJump(fn, loop, nil) fn.currentBlock = loop // loop: // jump := READY anonIdx := len(fn.AnonFuncs) jump := newVar(fmt.Sprintf("jump$%d", anonIdx+1), tInt) emitLocalVar(fn, jump, nil) // zero value is READY xsig := typeutil.CoreType(x.Type()).(*types.Signature) ysig := typeutil.CoreType(xsig.Params().At(0).Type()).(*types.Signature) /* synthetic yield function for body of range-over-func loop */ y := &Function{ name: fmt.Sprintf("%s$%d", fn.Name(), anonIdx+1), Signature: ysig, Synthetic: SyntheticRangeOverFuncYield, parent: fn, Pkg: fn.Pkg, Prog: fn.Prog, functionBody: new(functionBody), } y.source = rng y.goversion = fn.goversion y.jump = jump y.deferstack = fn.deferstack y.returnVars = fn.returnVars // use the parent's return variables y.uniq = fn.uniq // start from parent's unique values // If the RangeStmt has a label, this is how it is passed to buildYieldFunc. if label != nil { y.lblocks = map[*types.Label]*lblock{label.label: nil} } fn.AnonFuncs = append(fn.AnonFuncs, y) // Build y immediately. It may: // * cause fn's locals to escape, and // * create new exit nodes in exits. // (y is not marked 'built' until the end of the enclosing FuncDecl.) unresolved := len(fn.exits) b.buildYieldFunc(y) fn.uniq = y.uniq // resume after y's unique values // Emit the call of y. // c := MakeClosure y // x(c) c := &MakeClosure{Fn: y} c.setType(ysig) c.comment = "yield" for _, fv := range y.FreeVars { c.Bindings = append(c.Bindings, fv.outer) fv.outer = nil } fn.emit(c, nil) call := Call{ Call: CallCommon{ Value: x, Args: []Value{c}, }, } call.setType(xsig.Results()) fn.emit(&call, nil) exits := fn.exits[unresolved:] b.buildYieldResume(fn, jump, exits, done) fn.currentBlock = done } // buildYieldResume emits to fn code for how to resume execution once a call to // the iterator function over the yield function returns x(y). It does this by building // a switch over the value of jump for when it is READY, BUSY, or EXIT(id). func (b *builder) buildYieldResume(fn *Function, jump *types.Var, exits []*exit, done *BasicBlock) { // v := *jump // switch v { // case BUSY: panic("...") // case READY: jump = DONE; goto done // case EXIT(a): ... // case EXIT(b): ... // ... // } v := emitLoad(fn, fn.lookup(jump, false), nil) entry := fn.currentBlock bodies := make([]*BasicBlock, 2, 2+len(exits)) bodies[0] = fn.newBasicBlock("rangefunc.resume.busy") bodies[1] = fn.newBasicBlock("rangefunc.resume.ready") conds := make([]Value, 2, 2+len(exits)) conds[0] = emitConst(fn, jBusy()) conds[1] = emitConst(fn, jReady()) fn.currentBlock = bodies[0] fn.emit( &Panic{ X: emitConv(fn, emitConst(fn, stringConst("iterator call did not preserve panic", nil)), tEface, nil), }, nil, ) addEdge(fn.currentBlock, fn.Exit) fn.currentBlock = bodies[1] storeVar(fn, jump, emitConst(fn, jDone()), nil) emitJump(fn, done, nil) for _, e := range exits { body := fn.newBasicBlock(fmt.Sprintf("rangefunc.resume.exit.%d", e.id)) bodies = append(bodies, body) id_ := intConst(e.id, nil) id_.comment = fmt.Sprintf("rangefunc.exit.%d", e.id) id := emitConst(fn, id_) conds = append(conds, id) fn.currentBlock = body switch { case e.label != nil: // forward goto? // case EXIT(id): goto lb // label lb := fn.lblockOf(e.label) // Do not mark lb as resolved. // If fn does not contain label, lb remains unresolved and // fn must itself be a range-over-func function. lb will be: // lb: // fn.jump = id // return false emitJump(fn, lb._goto, e.source) case e.to != fn: // e jumps to an ancestor of fn? // case EXIT(id): { fn.jump = id; return false } // fn is a range-over-func function. storeVar(fn, fn.jump, id, e.source) vFalse := emitConst(fn, NewConst(constant.MakeBool(false), tBool, e.source)) emitReturn(fn, []Value{vFalse}, e.source) case e.block == nil && e.label == nil: // return from fn? // case EXIT(id): { return ... } // The results have already been stored to variables in fn.results, so // emitReturn doesn't have to do it again. emitReturn(fn, nil, e.source) case e.block != nil: // case EXIT(id): goto block emitJump(fn, e.block, e.source) default: panic("unreachable") } } fn.currentBlock = entry // Note that this switch does not have an implicit default case. This wouldn't be // valid for a user-provided switch statement, but for range-over-func we know all // possible values and we can avoid the impossible branch. swtch := &ConstantSwitch{ Tag: v, Conds: conds, } fn.emit(swtch, nil) for _, body := range bodies { addEdge(entry, body) } } // stmt lowers statement s to IR form, emitting code to fn. func (b *builder) stmt(fn *Function, _s ast.Stmt) { // The label of the current statement. If non-nil, its _goto // target is always set; its _break and _continue are set only // within the body of switch/typeswitch/select/for/range. // It is effectively an additional default-nil parameter of stmt(). var label *lblock start: switch s := _s.(type) { case *ast.EmptyStmt: // ignore. (Usually removed by gofmt.) case *ast.DeclStmt: // Con, Var or Typ d := s.Decl.(*ast.GenDecl) if d.Tok == token.VAR { for _, spec := range d.Specs { if vs, ok := spec.(*ast.ValueSpec); ok { b.localValueSpec(fn, vs) } } } case *ast.LabeledStmt: if s.Label.Name == "_" { // Blank labels can't be the target of a goto, break, // or continue statement, so we don't need a new block. _s = s.Stmt goto start } label = fn.lblockOf(fn.label(s.Label)) label.resolved = true emitJump(fn, label._goto, s) fn.currentBlock = label._goto _s = s.Stmt goto start // effectively: tailcall stmt(fn, s.Stmt, label) case *ast.ExprStmt: b.expr(fn, s.X) case *ast.SendStmt: instr := &Send{ Chan: b.expr(fn, s.Chan), X: emitConv(fn, b.expr(fn, s.Value), typeutil.CoreType(fn.Pkg.typeOf(s.Chan)).Underlying().(*types.Chan).Elem(), s), } fn.emit(instr, s) case *ast.IncDecStmt: op := token.ADD if s.Tok == token.DEC { op = token.SUB } loc := b.addr(fn, s.X, false) b.assignOp(fn, loc, emitConst(fn, NewConst(constant.MakeInt64(1), loc.typ(), s)), op, s) case *ast.AssignStmt: switch s.Tok { case token.ASSIGN, token.DEFINE: b.assignStmt(fn, s.Lhs, s.Rhs, s.Tok == token.DEFINE, _s) default: // +=, etc. op := s.Tok + token.ADD - token.ADD_ASSIGN b.assignOp(fn, b.addr(fn, s.Lhs[0], false), b.expr(fn, s.Rhs[0]), op, s) } case *ast.GoStmt: // The "intrinsics" new/make/len/cap are forbidden here. // panic is treated like an ordinary function call. v := Go{} b.setCall(fn, s.Call, &v.Call) fn.emit(&v, s) case *ast.DeferStmt: // The "intrinsics" new/make/len/cap are forbidden here. // panic is treated like an ordinary function call. deferstack := emitLoad(fn, fn.lookup(fn.deferstack, false), s) v := Defer{_DeferStack: deferstack} b.setCall(fn, s.Call, &v.Call) fn.hasDefer = true fn.emit(&v, s) case *ast.ReturnStmt: b.returnStmt(fn, s) case *ast.BranchStmt: b.branchStmt(fn, s) case *ast.BlockStmt: b.stmtList(fn, s.List) case *ast.IfStmt: if s.Init != nil { b.stmt(fn, s.Init) } then := fn.newBasicBlock("if.then") done := fn.newBasicBlock("if.done") els := done if s.Else != nil { els = fn.newBasicBlock("if.else") } instr := b.cond(fn, s.Cond, then, els) instr.source = s fn.currentBlock = then b.stmt(fn, s.Body) emitJump(fn, done, s) if s.Else != nil { fn.currentBlock = els b.stmt(fn, s.Else) emitJump(fn, done, s) } fn.currentBlock = done case *ast.SwitchStmt: b.switchStmt(fn, s, label) case *ast.TypeSwitchStmt: b.typeSwitchStmt(fn, s, label) case *ast.SelectStmt: if b.selectStmt(fn, s, label) { // the select has no cases, it blocks forever fn.currentBlock = fn.newBasicBlock("unreachable") } case *ast.ForStmt: b.forStmt(fn, s, label) case *ast.RangeStmt: b.rangeStmt(fn, s, label, s) default: panic(fmt.Sprintf("unexpected statement kind: %T", s)) } } func (b *builder) branchStmt(fn *Function, s *ast.BranchStmt) { var block *BasicBlock if s.Label == nil { block = targetedBlock(fn, s.Tok) } else { target := fn.label(s.Label) block = labelledBlock(fn, target, s.Tok) if block == nil { // forward goto lb := fn.lblockOf(target) block = lb._goto // jump to lb._goto if fn.jump != nil { // fn is a range-over-func and the goto may exit fn. // Create an exit and resolve it at the end of // builder.buildYieldFunc. labelExit(fn, target, s) } } } to := block.parent if to == fn { emitJump(fn, block, s) } else { // break outside of fn. // fn must be a range-over-func e := blockExit(fn, block, s) id_ := intConst(e.id, s) id_.comment = fmt.Sprintf("rangefunc.exit.%d", e.id) id := emitConst(fn, id_) storeVar(fn, fn.jump, id, s) vFalse := emitConst(fn, NewConst(constant.MakeBool(false), tBool, s)) emitReturn(fn, []Value{vFalse}, s) } fn.currentBlock = fn.newBasicBlock("unreachable") } func (b *builder) returnStmt(fn *Function, s *ast.ReturnStmt) { // TODO(dh): we could emit tighter position information by // using the ith returned expression var results []Value sig := fn.sourceFn.Signature // signature of the enclosing source function // Convert return operands to result type. if len(s.Results) == 1 && sig.Results().Len() > 1 { // Return of one expression in a multi-valued function. tuple := b.exprN(fn, s.Results[0]) ttuple := tuple.Type().(*types.Tuple) for i, n := 0, ttuple.Len(); i < n; i++ { results = append(results, emitConv(fn, emitExtract(fn, tuple, i, s), sig.Results().At(i).Type(), s)) } } else { // 1:1 return, or no-arg return in non-void function. for i, r := range s.Results { v := emitConv(fn, b.expr(fn, r), sig.Results().At(i).Type(), s) results = append(results, v) } } // Store the results. for i, r := range results { var result Value // fn.sourceFn.result[i] conceptually if fn == fn.sourceFn { result = fn.results[i] } else { // lookup needed? result = fn.lookup(fn.returnVars[i], false) } emitStore(fn, result, r, s) } if fn.jump != nil { // Return from body of a range-over-func. // The return statement is syntactically within the loop, // but the generated code is in the 'switch jump {...}' after it. e := returnExit(fn, s) id_ := intConst(e.id, e.source) id_.comment = fmt.Sprintf("rangefunc.exit.%d", e.id) id := emitConst(fn, id_) storeVar(fn, fn.jump, id, e.source) vFalse := emitConst(fn, NewConst(constant.MakeBool(false), tBool, e.source)) emitReturn(fn, []Value{vFalse}, e.source) return } // The results have already been stored to variables in fn.results, so // emitReturn doesn't have to do it again. emitReturn(fn, nil, s) } func emitReturn(fn *Function, results []Value, source ast.Node) { for i, r := range results { emitStore(fn, fn.results[i], r, source) } emitJump(fn, fn.Exit, source) fn.currentBlock = fn.newBasicBlock("unreachable") } // buildFunction builds IR code for the body of function fn. Idempotent. func (b *builder) buildFunction(fn *Function) { if fn.Blocks != nil { return // building already started } var recvField *ast.FieldList var body *ast.BlockStmt var functype *ast.FuncType switch n := fn.source.(type) { case nil: return // not a Go source function. (Synthetic, or from object file.) case *ast.FuncDecl: functype = n.Type recvField = n.Recv body = n.Body case *ast.FuncLit: functype = n.Type body = n.Body default: panic(n) } if fn.Package().Pkg.Path() == "syscall" && fn.Name() == "Exit" { // syscall.Exit is a stub and the way os.Exit terminates the // process. Note that there are other functions in the runtime // that also terminate or unwind that we cannot analyze. // However, they aren't stubs, so buildExits ends up getting // called on them, so that's where we handle those special // cases. fn.NoReturn = AlwaysExits } if body == nil { // External function. if fn.Params == nil { // This condition ensures we add a non-empty // params list once only, but we may attempt // the degenerate empty case repeatedly. // TODO(adonovan): opt: don't do that. // We set Function.Params even though there is no body // code to reference them. This simplifies clients. if recv := fn.Signature.Recv(); recv != nil { // XXX synthesize an ast.Node fn.addParamVar(recv, nil) } params := fn.Signature.Params() for i, n := 0, params.Len(); i < n; i++ { // XXX synthesize an ast.Node fn.addParamVar(params.At(i), nil) } } return } if fn.Prog.mode&LogSource != 0 { defer logStack("build function %s @ %s", fn, fn.Prog.Fset.Position(fn.Pos()))() } fn.blocksets = b.blocksets fn.Blocks = make([]*BasicBlock, 0, avgBlocks) fn.sourceFn = fn fn.startBody() fn.createSyntacticParams(recvField, functype) fn.createDeferStack() fn.exitBlock() b.stmt(fn, body) if cb := fn.currentBlock; cb != nil && (cb == fn.Blocks[0] || cb.Preds != nil) { // Control fell off the end of the function's body block. // // Block optimizations eliminate the current block, if // unreachable. It is a builder invariant that // if this no-arg return is ill-typed for // fn.Signature.Results, this block must be // unreachable. The sanity checker checks this. // fn.emit(new(RunDefers)) // fn.emit(new(Return)) emitJump(fn, fn.Exit, nil) } optimizeBlocks(fn) buildFakeExits(fn) b.buildExits(fn) b.addUnreachables(fn) fn.finishBody() b.blocksets = fn.blocksets fn.functionBody = nil } // buildYieldFunc builds the body of the yield function created // from a range-over-func *ast.RangeStmt. func (b *builder) buildYieldFunc(fn *Function) { // See builder.rangeFunc for detailed documentation on how fn is set up. // // In psuedo-Go this roughly builds: // func yield(_k tk, _v tv) bool { // if jump != READY { panic("yield function called after range loop exit") } // jump = BUSY // k, v = _k, _v // assign the iterator variable (if needed) // ... // rng.Body // continue: // jump = READY // return true // } s := fn.source.(*ast.RangeStmt) fn.sourceFn = fn.parent.sourceFn fn.startBody() params := fn.Signature.Params() for i := 0; i < params.Len(); i++ { fn.addParamVar(params.At(i), nil) } fn.addResultVar(fn.Signature.Results().At(0), nil) fn.exitBlock() // Initial targets ycont := fn.newBasicBlock("yield-continue") // lblocks is either {} or is {label: nil} where label is the label of syntax. for label := range fn.lblocks { fn.lblocks[label] = &lblock{ label: label, resolved: true, _goto: ycont, _continue: ycont, // `break label` statement targets fn.parent.targets._break } } fn.targets = &targets{ _continue: ycont, // `break` statement targets fn.parent.targets._break. } // continue: // jump = READY // return true saved := fn.currentBlock fn.currentBlock = ycont storeVar(fn, fn.jump, emitConst(fn, jReady()), s.Body) vTrue := emitConst(fn, NewConst(constant.MakeBool(true), tBool, nil)) emitReturn(fn, []Value{vTrue}, nil) // Emit header: // // if jump != READY { panic("yield iterator accessed after exit") } // jump = BUSY // k, v = _k, _v fn.currentBlock = saved yloop := fn.newBasicBlock("yield-loop") invalid := fn.newBasicBlock("yield-invalid") jumpVal := emitLoad(fn, fn.lookup(fn.jump, true), nil) emitIf(fn, emitCompare(fn, token.EQL, jumpVal, emitConst(fn, jReady()), nil), yloop, invalid, nil) fn.currentBlock = invalid fn.emit( &Panic{ X: emitConv(fn, emitConst(fn, stringConst("yield function called after range loop exit", nil)), tEface, nil), }, nil, ) addEdge(fn.currentBlock, fn.Exit) fn.currentBlock = yloop storeVar(fn, fn.jump, emitConst(fn, jBusy()), s.Body) // Initialize k and v from params. var tk, tv types.Type if s.Key != nil && !isBlankIdent(s.Key) { tk = fn.Pkg.typeOf(s.Key) // fn.parent.typeOf is identical } if s.Value != nil && !isBlankIdent(s.Value) { tv = fn.Pkg.typeOf(s.Value) } if s.Tok == token.DEFINE { if tk != nil { emitLocalVar(fn, identVar(fn, s.Key.(*ast.Ident)), s.Key) } if tv != nil { emitLocalVar(fn, identVar(fn, s.Value.(*ast.Ident)), s.Value) } } var k, v Value if len(fn.Params) > 0 { k = fn.Params[0] } if len(fn.Params) > 1 { v = fn.Params[1] } var kl, vl lvalue if tk != nil { kl = b.addr(fn, s.Key, false) // non-escaping } if tv != nil { vl = b.addr(fn, s.Value, false) // non-escaping } if tk != nil { kl.store(fn, k, s.Key) } if tv != nil { vl.store(fn, v, s.Value) } // Build the body of the range loop. b.stmt(fn, s.Body) if cb := fn.currentBlock; cb != nil && (cb == fn.Blocks[0] || cb.Preds != nil) { // Control fell off the end of the function's body block. // Block optimizations eliminate the current block, if // unreachable. emitJump(fn, ycont, nil) } // Clean up exits and promote any unresolved exits to fn.parent. for _, e := range fn.exits { if e.label != nil { lb := fn.lblocks[e.label] if lb.resolved { // label was resolved. Do not turn lb into an exit. // e does not need to be handled by the parent. continue } // _goto becomes an exit. // _goto: // jump = id // return false fn.currentBlock = lb._goto id_ := intConst(e.id, e.source) id_.comment = fmt.Sprintf("rangefunc.exit.%d", e.id) id := emitConst(fn, id_) storeVar(fn, fn.jump, id, e.source) vFalse := emitConst(fn, NewConst(constant.MakeBool(false), tBool, e.source)) emitReturn(fn, []Value{vFalse}, e.source) } if e.to != fn { // e needs to be handled by the parent too. fn.parent.exits = append(fn.parent.exits, e) } } fn.finishBody() } // buildFuncDecl builds IR code for the function or method declared // by decl in package pkg. func (b *builder) buildFuncDecl(pkg *Package, decl *ast.FuncDecl) { id := decl.Name fn := pkg.values[pkg.info.Defs[id]].(*Function) if decl.Recv == nil && id.Name == "init" { var v Call v.Call.Value = fn v.setType(types.NewTuple()) pkg.init.emit(&v, decl) } fn.source = decl b.buildFunction(fn) } // Build calls Package.Build for each package in prog. // // Build is intended for whole-program analysis; a typical compiler // need only build a single package. // // Build is idempotent and thread-safe. func (prog *Program) Build() { for _, p := range prog.packages { p.Build() } } // Build builds IR code for all functions and vars in package p. // // Precondition: CreatePackage must have been called for all of p's // direct imports (and hence its direct imports must have been // error-free). // // Build is idempotent and thread-safe. func (p *Package) Build() { p.buildOnce.Do(p.build) } func (p *Package) build() { if p.info == nil { return // synthetic package, e.g. "testmain" } // Ensure we have runtime type info for all exported members. // TODO(adonovan): ideally belongs in memberFromObject, but // that would require package creation in topological order. for name, mem := range p.Members { if ast.IsExported(name) { p.Prog.needMethodsOf(mem.Type()) } } if p.Prog.mode&LogSource != 0 { defer logStack("build %s", p)() } init := p.init init.startBody() init.exitBlock() var done *BasicBlock // Make init() skip if package is already initialized. initguard := p.Var("init$guard") doinit := init.newBasicBlock("init.start") done = init.Exit emitIf(init, emitLoad(init, initguard, nil), done, doinit, nil) init.currentBlock = doinit emitStore(init, initguard, emitConst(init, NewConst(constant.MakeBool(true), tBool, nil)), nil) // Call the init() function of each package we import. for _, pkg := range p.Pkg.Imports() { prereq := p.Prog.packages[pkg] if prereq == nil { panic(fmt.Sprintf("Package(%q).Build(): unsatisfied import: Program.CreatePackage(%q) was not called", p.Pkg.Path(), pkg.Path())) } var v Call v.Call.Value = prereq.init v.setType(types.NewTuple()) init.emit(&v, nil) } b := builder{ printFunc: p.printFunc, } // Initialize package-level vars in correct order. for _, varinit := range p.info.InitOrder { if init.Prog.mode&LogSource != 0 { fmt.Fprintf(os.Stderr, "build global initializer %v @ %s\n", varinit.Lhs, p.Prog.Fset.Position(varinit.Rhs.Pos())) } // Initializers for global vars are evaluated in dependency // order, but may come from arbitrary files of the package // with different versions, so we transiently update // init.goversion for each one. (Since init is a synthetic // function it has no syntax of its own that needs a version.) init.goversion = p.initVersion[varinit.Rhs] if len(varinit.Lhs) == 1 { // 1:1 initialization: var x, y = a(), b() var lval lvalue if v := varinit.Lhs[0]; v.Name() != "_" { lval = &address{addr: p.values[v].(*Global)} } else { lval = blank{} } // TODO(dh): do emit position information b.assign(init, lval, varinit.Rhs, true, nil, nil) } else { // n:1 initialization: var x, y := f() tuple := b.exprN(init, varinit.Rhs) for i, v := range varinit.Lhs { if v.Name() == "_" { continue } emitStore(init, p.values[v].(*Global), emitExtract(init, tuple, i, nil), nil) } } } init.goversion = "" // The rest of the init function is synthetic. No syntax => no goversion. // Build all package-level functions, init functions // and methods, including unreachable/blank ones. // We build them in source order, but it's not significant. for _, file := range p.files { for _, decl := range file.Decls { if decl, ok := decl.(*ast.FuncDecl); ok { b.buildFuncDecl(p, decl) } } } // Finish up init(). emitJump(init, done, nil) init.finishBody() // We no longer need ASTs or go/types deductions. p.info = nil p.initVersion = nil if p.Prog.mode&SanityCheckFunctions != 0 { sanityCheckPackage(p) } } // Like ObjectOf, but panics instead of returning nil. // Only valid during p's create and build phases. func (p *Package) objectOf(id *ast.Ident) types.Object { if o := p.info.ObjectOf(id); o != nil { return o } panic(fmt.Sprintf("no types.Object for ast.Ident %s @ %s", id.Name, p.Prog.Fset.Position(id.Pos()))) } // Like TypeOf, but panics instead of returning nil. // Only valid during p's create and build phases. func (p *Package) typeOf(e ast.Expr) types.Type { if T := p.info.TypeOf(e); T != nil { return T } panic(fmt.Sprintf("no type for %T @ %s", e, p.Prog.Fset.Position(e.Pos()))) } golang-honnef-go-tools-2024.1/go/ir/builder_test.go000066400000000000000000000473461465704072200221450ustar00rootroot00000000000000// Copyright 2013 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. //lint:file-ignore SA1019 go/ssa's test suite is built around the deprecated go/loader. We'll leave fixing that to upstream. package ir_test import ( "bytes" "go/ast" "go/importer" "go/parser" "go/token" "go/types" "os" "reflect" "sort" "testing" "honnef.co/go/tools/go/ir" "honnef.co/go/tools/go/ir/irutil" "golang.org/x/tools/go/loader" ) func isEmpty(f *ir.Function) bool { return f.Blocks == nil } // Tests that programs partially loaded from gc object files contain // functions with no code for the external portions, but are otherwise ok. func TestBuildPackage(t *testing.T) { input := ` package main import ( "bytes" "io" "testing" ) func main() { var t testing.T t.Parallel() // static call to external declared method t.Fail() // static call to promoted external declared method testing.Short() // static call to external package-level function var w io.Writer = new(bytes.Buffer) w.Write(nil) // interface invoke of external declared method } ` // Parse the file. fset := token.NewFileSet() f, err := parser.ParseFile(fset, "input.go", input, parser.SkipObjectResolution) if err != nil { t.Error(err) return } // Build an IR program from the parsed file. // Load its dependencies from gc binary export data. mainPkg, _, err := irutil.BuildPackage(&types.Config{Importer: importer.Default()}, fset, types.NewPackage("main", ""), []*ast.File{f}, ir.SanityCheckFunctions) if err != nil { t.Error(err) return } // The main package, its direct and indirect dependencies are loaded. deps := []string{ // directly imported dependencies: "bytes", "io", "testing", // indirect dependencies mentioned by // the direct imports' export data "sync", "unicode", "time", } prog := mainPkg.Prog all := prog.AllPackages() if len(all) <= len(deps) { t.Errorf("unexpected set of loaded packages: %q", all) } for _, path := range deps { pkg := prog.ImportedPackage(path) if pkg == nil { t.Errorf("package not loaded: %q", path) continue } // External packages should have no function bodies (except for wrappers). isExt := pkg != mainPkg // init() if isExt && !isEmpty(pkg.Func("init")) { t.Errorf("external package %s has non-empty init", pkg) } else if !isExt && isEmpty(pkg.Func("init")) { t.Errorf("main package %s has empty init", pkg) } for _, mem := range pkg.Members { switch mem := mem.(type) { case *ir.Function: // Functions at package level. if isExt && !isEmpty(mem) { t.Errorf("external function %s is non-empty", mem) } else if !isExt && isEmpty(mem) { t.Errorf("function %s is empty", mem) } case *ir.Type: // Methods of named types T. // (In this test, all exported methods belong to *T not T.) if !isExt { t.Fatalf("unexpected name type in main package: %s", mem) } mset := prog.MethodSets.MethodSet(types.NewPointer(mem.Type())) for i, n := 0, mset.Len(); i < n; i++ { m := prog.MethodValue(mset.At(i)) // For external types, only synthetic wrappers have code. expExt := m.Synthetic != ir.SyntheticWrapper if expExt && !isEmpty(m) { t.Errorf("external method %s is non-empty: %s", m, m.Synthetic) } else if !expExt && isEmpty(m) { t.Errorf("method function %s is empty: %s", m, m.Synthetic) } } } } } expectedCallee := []string{ "(*testing.T).Parallel", "(*testing.common).Fail", "testing.Short", "N/A", } callNum := 0 for _, b := range mainPkg.Func("main").Blocks { for _, instr := range b.Instrs { switch instr := instr.(type) { case ir.CallInstruction: call := instr.Common() if want := expectedCallee[callNum]; want != "N/A" { got := call.StaticCallee().String() if want != got { t.Errorf("call #%d from main.main: got callee %s, want %s", callNum, got, want) } } callNum++ } } } if callNum != 4 { t.Errorf("in main.main: got %d calls, want %d", callNum, 4) } } // TestRuntimeTypes tests that (*Program).RuntimeTypes() includes all necessary types. func TestRuntimeTypes(t *testing.T) { tests := []struct { input string want []string }{ // An exported package-level type is needed. {`package A; type T struct{}; func (T) f() {}`, []string{"*p.T", "p.T"}, }, // An unexported package-level type is not needed. {`package B; type t struct{}; func (t) f() {}`, nil, }, // Subcomponents of type of exported package-level var are needed. {`package C; import "bytes"; var V struct {*bytes.Buffer}`, []string{"*bytes.Buffer", "*struct{*bytes.Buffer}", "struct{*bytes.Buffer}"}, }, // Subcomponents of type of unexported package-level var are not needed. {`package D; import "bytes"; var v struct {*bytes.Buffer}`, nil, }, // Subcomponents of type of exported package-level function are needed. {`package E; import "bytes"; func F(struct {*bytes.Buffer}) {}`, []string{"*bytes.Buffer", "struct{*bytes.Buffer}"}, }, // Subcomponents of type of unexported package-level function are not needed. {`package F; import "bytes"; func f(struct {*bytes.Buffer}) {}`, nil, }, // Subcomponents of type of exported method of uninstantiated unexported type are not needed. {`package G; import "bytes"; type x struct{}; func (x) G(struct {*bytes.Buffer}) {}; var v x`, nil, }, // ...unless used by MakeInterface. {`package G2; import "bytes"; type x struct{}; func (x) G(struct {*bytes.Buffer}) {}; var v interface{} = x{}`, []string{"*bytes.Buffer", "*p.x", "p.x", "struct{*bytes.Buffer}"}, }, // Subcomponents of type of unexported method are not needed. {`package I; import "bytes"; type X struct{}; func (X) G(struct {*bytes.Buffer}) {}`, []string{"*bytes.Buffer", "*p.X", "p.X", "struct{*bytes.Buffer}"}, }, // Local types aren't needed. {`package J; import "bytes"; func f() { type T struct {*bytes.Buffer}; var t T; _ = t }`, nil, }, // ...unless used by MakeInterface. {`package K; import "bytes"; func f() { type T struct {*bytes.Buffer}; _ = interface{}(T{}) }`, []string{"*bytes.Buffer", "*p.T", "p.T"}, }, // Types used as operand of MakeInterface are needed. {`package L; import "bytes"; func f() { _ = interface{}(struct{*bytes.Buffer}{}) }`, []string{"*bytes.Buffer", "struct{*bytes.Buffer}"}, }, // MakeInterface is optimized away when storing to a blank. {`package M; import "bytes"; var _ interface{} = struct{*bytes.Buffer}{}`, nil, }, } for _, test := range tests { // Parse the file. fset := token.NewFileSet() f, err := parser.ParseFile(fset, "input.go", test.input, 0) if err != nil { t.Errorf("test %q: %s", test.input[:15], err) continue } // Create a single-file main package. // Load dependencies from gc binary export data. irpkg, _, err := irutil.BuildPackage(&types.Config{Importer: importer.Default()}, fset, types.NewPackage("p", ""), []*ast.File{f}, ir.SanityCheckFunctions) if err != nil { t.Errorf("test %q: %s", test.input[:15], err) continue } var typstrs []string for _, T := range irpkg.Prog.RuntimeTypes() { typstrs = append(typstrs, T.String()) } sort.Strings(typstrs) if !reflect.DeepEqual(typstrs, test.want) { t.Errorf("test 'package %s': got %q, want %q", f.Name.Name, typstrs, test.want) } } } // TestInit tests that synthesized init functions are correctly formed. func TestInit(t *testing.T) { tests := []struct { mode ir.BuilderMode input, want string }{ {0, `package A; import _ "errors"; var i int = 42`, `# Name: A.init # Package: A # Synthetic: package initializer func init(): b0: # entry t1 = Const {true} t2 = Const {42} t3 = Load init$guard If t3 → b1 b2 b1: ← b0 b2 # exit Return b2: ← b0 # init.start Store {bool} init$guard t1 t7 = Call <()> errors.init Store {int} i t2 Jump → b1 `}, } for _, test := range tests { // Create a single-file main package. var conf loader.Config f, err := conf.ParseFile("", test.input) if err != nil { t.Errorf("test %q: %s", test.input[:15], err) continue } conf.CreateFromFiles(f.Name.Name, f) lprog, err := conf.Load() if err != nil { t.Errorf("test 'package %s': Load: %s", f.Name.Name, err) continue } prog := irutil.CreateProgram(lprog, test.mode) mainPkg := prog.Package(lprog.Created[0].Pkg) prog.Build() initFunc := mainPkg.Func("init") if initFunc == nil { t.Errorf("test 'package %s': no init function", f.Name.Name) continue } var initbuf bytes.Buffer _, err = initFunc.WriteTo(&initbuf) if err != nil { t.Errorf("test 'package %s': WriteTo: %s", f.Name.Name, err) continue } if initbuf.String() != test.want { t.Errorf("test 'package %s': got %s, want %s", f.Name.Name, initbuf.String(), test.want) } } } // TestSyntheticFuncs checks that the expected synthetic functions are // created, reachable, and not duplicated. func TestSyntheticFuncs(t *testing.T) { const input = `package P type T int func (T) f() int func (*T) g() int var ( // thunks a = T.f b = T.f c = (struct{T}).f d = (struct{T}).f e = (*T).g f = (*T).g g = (struct{*T}).g h = (struct{*T}).g // bounds i = T(0).f j = T(0).f k = new(T).g l = new(T).g // wrappers m interface{} = struct{T}{} n interface{} = struct{T}{} o interface{} = struct{*T}{} p interface{} = struct{*T}{} q interface{} = new(struct{T}) r interface{} = new(struct{T}) s interface{} = new(struct{*T}) t interface{} = new(struct{*T}) ) ` // Parse var conf loader.Config f, err := conf.ParseFile("", input) if err != nil { t.Fatalf("parse: %v", err) } conf.CreateFromFiles(f.Name.Name, f) // Load lprog, err := conf.Load() if err != nil { t.Fatalf("Load: %v", err) } // Create and build IR prog := irutil.CreateProgram(lprog, 0) prog.Build() // Enumerate reachable synthetic functions want := map[string]ir.Synthetic{ "(*P.T).g$bound": ir.SyntheticBound, "(P.T).f$bound": ir.SyntheticBound, "(*P.T).g$thunk": ir.SyntheticThunk, "(P.T).f$thunk": ir.SyntheticThunk, "(struct{*P.T}).g$thunk": ir.SyntheticThunk, "(struct{P.T}).f$thunk": ir.SyntheticThunk, "(*P.T).f": ir.SyntheticWrapper, "(*struct{*P.T}).f": ir.SyntheticWrapper, "(*struct{*P.T}).g": ir.SyntheticWrapper, "(*struct{P.T}).f": ir.SyntheticWrapper, "(*struct{P.T}).g": ir.SyntheticWrapper, "(struct{*P.T}).f": ir.SyntheticWrapper, "(struct{*P.T}).g": ir.SyntheticWrapper, "(struct{P.T}).f": ir.SyntheticWrapper, "P.init": ir.SyntheticPackageInitializer, } var seen []string // may contain dups for fn := range irutil.AllFunctions(prog) { if fn.Synthetic == 0 { continue } name := fn.String() wantDescr, ok := want[name] if !ok { t.Errorf("got unexpected/duplicate func: %q: %q", name, fn.Synthetic) continue } seen = append(seen, name) if wantDescr != fn.Synthetic { t.Errorf("(%s).Synthetic = %q, want %q", name, fn.Synthetic, wantDescr) } } for _, name := range seen { delete(want, name) } for fn, descr := range want { t.Errorf("want func: %q: %q", fn, descr) } } // TestPhiElimination ensures that dead phis, including those that // participate in a cycle, are properly eliminated. func TestPhiElimination(t *testing.T) { const input = ` package p func f() error func g(slice []int) { for { for range slice { // e should not be lifted to a dead φ-node. e := f() h(e) } } } func h(error) ` // The IR code for this function should look something like this: // 0: // jump 1 // 1: // t0 = len(slice) // jump 2 // 2: // t1 = phi [1: -1:int, 3: t2] // t2 = t1 + 1:int // t3 = t2 < t0 // if t3 goto 3 else 1 // 3: // t4 = f() // t5 = h(t4) // jump 2 // // But earlier versions of the IR construction algorithm would // additionally generate this cycle of dead phis: // // 1: // t7 = phi [0: nil:error, 2: t8] #e // ... // 2: // t8 = phi [1: t7, 3: t4] #e // ... // Parse var conf loader.Config f, err := conf.ParseFile("", input) if err != nil { t.Fatalf("parse: %v", err) } conf.CreateFromFiles("p", f) // Load lprog, err := conf.Load() if err != nil { t.Fatalf("Load: %v", err) } // Create and build IR prog := irutil.CreateProgram(lprog, 0) p := prog.Package(lprog.Package("p").Pkg) p.Build() g := p.Func("g") phis := 0 for _, b := range g.Blocks { for _, instr := range b.Instrs { if _, ok := instr.(*ir.Phi); ok { phis++ } } } if expected := 4; phis != expected { g.WriteTo(os.Stderr) t.Errorf("expected %d Phi nodes (for the range index, slice length and slice), got %d", expected, phis) } } func TestBuildPackageGo120(t *testing.T) { tests := []struct { name string src string importer types.Importer }{ {"slice to array", "package p; var s []byte; var _ = ([4]byte)(s)", nil}, {"slice to zero length array", "package p; var s []byte; var _ = ([0]byte)(s)", nil}, {"slice to zero length array type parameter", "package p; var s []byte; func f[T ~[0]byte]() { tmp := (T)(s); var z T; _ = tmp == z}", nil}, {"slice to non-zero length array type parameter", "package p; var s []byte; func h[T ~[1]byte | [4]byte]() { tmp := T(s); var z T; _ = tmp == z}", nil}, {"slice to maybe-zero length array type parameter", "package p; var s []byte; func g[T ~[0]byte | [4]byte]() { tmp := T(s); var z T; _ = tmp == z}", nil}, { "rune sequence to sequence cast patterns", ` package p // Each of fXX functions describes a 1.20 legal cast between sequences of runes // as []rune, pointers to rune arrays, rune arrays, or strings. // // Comments listed given the current emitted instructions [approximately]. // If multiple conversions are needed, these are separated by |. // rune was selected as it leads to string casts (byte is similar). // The length 2 is not significant. // Multiple array lengths may occur in a cast in practice (including 0). func f00[S string, D string](s S) { _ = D(s) } // ChangeType func f01[S string, D []rune](s S) { _ = D(s) } // Convert func f02[S string, D []rune | string](s S) { _ = D(s) } // ChangeType | Convert func f03[S [2]rune, D [2]rune](s S) { _ = D(s) } // ChangeType func f04[S *[2]rune, D *[2]rune](s S) { _ = D(s) } // ChangeType func f05[S []rune, D string](s S) { _ = D(s) } // Convert func f06[S []rune, D [2]rune](s S) { _ = D(s) } // SliceToArray func f07[S []rune, D [2]rune | string](s S) { _ = D(s) } // SliceToArray | Convert func f08[S []rune, D *[2]rune](s S) { _ = D(s) } // SliceToArrayPointer func f09[S []rune, D *[2]rune | string](s S) { _ = D(s) } // SliceToArray | Convert func f10[S []rune, D *[2]rune | [2]rune](s S) { _ = D(s) } // SliceToArrayPointer | SliceToArray func f11[S []rune, D *[2]rune | [2]rune | string](s S) { _ = D(s) } // SliceToArrayPointer | SliceToArray | Convert func f12[S []rune, D []rune](s S) { _ = D(s) } // ChangeType func f13[S []rune, D []rune | string](s S) { _ = D(s) } // Convert | ChangeType func f14[S []rune, D []rune | [2]rune](s S) { _ = D(s) } // ChangeType | SliceToArray func f15[S []rune, D []rune | [2]rune | string](s S) { _ = D(s) } // ChangeType | SliceToArray | Convert func f16[S []rune, D []rune | *[2]rune](s S) { _ = D(s) } // ChangeType | SliceToArrayPointer func f17[S []rune, D []rune | *[2]rune | string](s S) { _ = D(s) } // ChangeType | SliceToArrayPointer | Convert func f18[S []rune, D []rune | *[2]rune | [2]rune](s S) { _ = D(s) } // ChangeType | SliceToArrayPointer | SliceToArray func f19[S []rune, D []rune | *[2]rune | [2]rune | string](s S) { _ = D(s) } // ChangeType | SliceToArrayPointer | SliceToArray | Convert func f20[S []rune | string, D string](s S) { _ = D(s) } // Convert | ChangeType func f21[S []rune | string, D []rune](s S) { _ = D(s) } // Convert | ChangeType func f22[S []rune | string, D []rune | string](s S) { _ = D(s) } // ChangeType | Convert | Convert | ChangeType func f23[S []rune | [2]rune, D [2]rune](s S) { _ = D(s) } // SliceToArray | ChangeType func f24[S []rune | *[2]rune, D *[2]rune](s S) { _ = D(s) } // SliceToArrayPointer | ChangeType `, nil, }, { "matching named and underlying types", ` package p type a string type b string func g0[S []rune | a | b, D []rune | a | b](s S) { _ = D(s) } func g1[S []rune | ~string, D []rune | a | b](s S) { _ = D(s) } func g2[S []rune | a | b, D []rune | ~string](s S) { _ = D(s) } func g3[S []rune | ~string, D []rune |~string](s S) { _ = D(s) } `, nil, }, } for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { t.Parallel() fset := token.NewFileSet() f, err := parser.ParseFile(fset, "p.go", tc.src, 0) if err != nil { t.Error(err) } files := []*ast.File{f} pkg := types.NewPackage("p", "") conf := &types.Config{Importer: tc.importer} _, _, err = irutil.BuildPackage(conf, fset, pkg, files, ir.SanityCheckFunctions) if err != nil { t.Errorf("unexpected error: %v", err) } }) } } func TestGo117Builtins(t *testing.T) { tests := []struct { name string src string importer types.Importer }{ {"slice to array pointer", "package p; var s []byte; var _ = (*[4]byte)(s)", nil}, {"unsafe slice", `package p; import "unsafe"; var _ = unsafe.Add(nil, 0)`, importer.Default()}, {"unsafe add", `package p; import "unsafe"; var _ = unsafe.Slice((*int)(nil), 0)`, importer.Default()}, } for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { t.Parallel() fset := token.NewFileSet() f, err := parser.ParseFile(fset, "p.go", tc.src, parser.ParseComments|parser.SkipObjectResolution) if err != nil { t.Error(err) } files := []*ast.File{f} pkg := types.NewPackage("p", "") conf := &types.Config{Importer: tc.importer} if _, _, err := irutil.BuildPackage(conf, fset, pkg, files, ir.SanityCheckFunctions); err != nil { t.Errorf("unexpected error: %v", err) } }) } } // TestLabels just tests that anonymous labels are handled. func TestLabels(t *testing.T) { tests := []string{ `package main func main() { _:println(1) }`, `package main func main() { _:println(1); _:println(2)}`, } for _, test := range tests { conf := loader.Config{Fset: token.NewFileSet()} f, err := parser.ParseFile(conf.Fset, "", test, 0) if err != nil { t.Errorf("parse error: %s", err) return } conf.CreateFromFiles("main", f) iprog, err := conf.Load() if err != nil { t.Error(err) continue } prog := irutil.CreateProgram(iprog, ir.BuilderMode(0)) pkg := prog.Package(iprog.Created[0].Pkg) pkg.Build() } } func TestUnreachableExit(t *testing.T) { tests := []string{ ` package pkg func foo() (err error) { if true { println() } println() for { err = nil } }`, } for _, test := range tests { conf := loader.Config{Fset: token.NewFileSet()} f, err := parser.ParseFile(conf.Fset, "", test, 0) if err != nil { t.Errorf("parse error: %s", err) return } conf.CreateFromFiles("pkg", f) iprog, err := conf.Load() if err != nil { t.Error(err) continue } prog := irutil.CreateProgram(iprog, ir.BuilderMode(0)) pkg := prog.Package(iprog.Created[0].Pkg) pkg.Build() } } golang-honnef-go-tools-2024.1/go/ir/const.go000066400000000000000000000167061465704072200206020ustar00rootroot00000000000000// Copyright 2013 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. package ir // This file defines the Const SSA value type. import ( "fmt" "go/ast" "go/constant" "go/types" "strconv" "strings" "golang.org/x/exp/typeparams" "honnef.co/go/tools/go/types/typeutil" ) // NewConst returns a new constant of the specified value and type. // val must be valid according to the specification of Const.Value. func NewConst(val constant.Value, typ types.Type, source ast.Node) *Const { c := &Const{ register: register{ typ: typ, }, Value: val, } c.setSource(source) return c } // intConst returns an 'int' constant that evaluates to i. // (i is an int64 in case the host is narrower than the target.) func intConst(i int64, source ast.Node) *Const { return NewConst(constant.MakeInt64(i), tInt, source) } // nilConst returns a nil constant of the specified type, which may // be any reference type, including interfaces. func nilConst(typ types.Type, source ast.Node) *Const { return NewConst(nil, typ, source) } // stringConst returns a 'string' constant that evaluates to s. func stringConst(s string, source ast.Node) *Const { return NewConst(constant.MakeString(s), tString, source) } // zeroConst returns a new "zero" constant of the specified type. func zeroConst(t types.Type, source ast.Node) Constant { if _, ok := t.Underlying().(*types.Interface); ok && !typeparams.IsTypeParam(t) { // Handle non-generic interface early to simplify following code. return nilConst(t, source) } tset := typeutil.NewTypeSet(t) switch typ := tset.CoreType().(type) { case *types.Struct: values := make([]Value, typ.NumFields()) for i := 0; i < typ.NumFields(); i++ { values[i] = zeroConst(typ.Field(i).Type(), source) } ac := &AggregateConst{ register: register{typ: t}, Values: values, } ac.setSource(source) return ac case *types.Tuple: values := make([]Value, typ.Len()) for i := 0; i < typ.Len(); i++ { values[i] = zeroConst(typ.At(i).Type(), source) } ac := &AggregateConst{ register: register{typ: t}, Values: values, } ac.setSource(source) return ac } isNillable := func(term *types.Term) bool { switch typ := term.Type().Underlying().(type) { case *types.Pointer, *types.Slice, *types.Interface, *types.Chan, *types.Map, *types.Signature, *typeutil.Iterator: return true case *types.Basic: switch typ.Kind() { case types.UnsafePointer, types.UntypedNil: return true default: return false } default: return false } } isInfo := func(info types.BasicInfo) func(*types.Term) bool { return func(term *types.Term) bool { basic, ok := term.Type().Underlying().(*types.Basic) if !ok { return false } return (basic.Info() & info) != 0 } } isArray := func(term *types.Term) bool { _, ok := term.Type().Underlying().(*types.Array) return ok } switch { case tset.All(isInfo(types.IsNumeric)): return NewConst(constant.MakeInt64(0), t, source) case tset.All(isInfo(types.IsString)): return NewConst(constant.MakeString(""), t, source) case tset.All(isInfo(types.IsBoolean)): return NewConst(constant.MakeBool(false), t, source) case tset.All(isNillable): return nilConst(t, source) case tset.All(isArray): var k ArrayConst k.setType(t) k.setSource(source) return &k default: var k GenericConst k.setType(t) k.setSource(source) return &k } } func (c *Const) RelString(from *types.Package) string { var p string if c.Value == nil { p = "nil" } else if c.Value.Kind() == constant.String { v := constant.StringVal(c.Value) const max = 20 // TODO(adonovan): don't cut a rune in half. if len(v) > max { v = v[:max-3] + "..." // abbreviate } p = strconv.Quote(v) } else { p = c.Value.String() } return fmt.Sprintf("Const <%s> {%s}", relType(c.Type(), from), p) } func (c *Const) String() string { if c.block == nil { // Constants don't have a block till late in the compilation process. But we want to print consts during // debugging. return c.RelString(nil) } return c.RelString(c.Parent().pkg()) } func (v *ArrayConst) RelString(pkg *types.Package) string { return fmt.Sprintf("ArrayConst <%s>", relType(v.Type(), pkg)) } func (v *ArrayConst) String() string { return v.RelString(v.Parent().pkg()) } func (v *AggregateConst) RelString(pkg *types.Package) string { values := make([]string, len(v.Values)) for i, v := range v.Values { if v != nil { values[i] = v.Name() } else { values[i] = "nil" } } return fmt.Sprintf("AggregateConst <%s> (%s)", relType(v.Type(), pkg), strings.Join(values, ", ")) } func (v *AggregateConst) String() string { if v.block == nil { return v.RelString(nil) } return v.RelString(v.Parent().pkg()) } func (v *GenericConst) RelString(pkg *types.Package) string { return fmt.Sprintf("GenericConst <%s>", relType(v.Type(), pkg)) } func (v *GenericConst) String() string { return v.RelString(v.Parent().pkg()) } // IsNil returns true if this constant represents a typed or untyped nil value. func (c *Const) IsNil() bool { return c.Value == nil } // Int64 returns the numeric value of this constant truncated to fit // a signed 64-bit integer. func (c *Const) Int64() int64 { switch x := constant.ToInt(c.Value); x.Kind() { case constant.Int: if i, ok := constant.Int64Val(x); ok { return i } return 0 case constant.Float: f, _ := constant.Float64Val(x) return int64(f) } panic(fmt.Sprintf("unexpected constant value: %T", c.Value)) } // Uint64 returns the numeric value of this constant truncated to fit // an unsigned 64-bit integer. func (c *Const) Uint64() uint64 { switch x := constant.ToInt(c.Value); x.Kind() { case constant.Int: if u, ok := constant.Uint64Val(x); ok { return u } return 0 case constant.Float: f, _ := constant.Float64Val(x) return uint64(f) } panic(fmt.Sprintf("unexpected constant value: %T", c.Value)) } // Float64 returns the numeric value of this constant truncated to fit // a float64. func (c *Const) Float64() float64 { f, _ := constant.Float64Val(c.Value) return f } // Complex128 returns the complex value of this constant truncated to // fit a complex128. func (c *Const) Complex128() complex128 { re, _ := constant.Float64Val(constant.Real(c.Value)) im, _ := constant.Float64Val(constant.Imag(c.Value)) return complex(re, im) } func (c *Const) equal(o Constant) bool { // TODO(dh): don't use == for types, this will miss identical pointer types, among others oc, ok := o.(*Const) if !ok { return false } return c.typ == oc.typ && c.Value == oc.Value && c.source == oc.source } func (c *AggregateConst) equal(o Constant) bool { oc, ok := o.(*AggregateConst) if !ok { return false } // TODO(dh): don't use == for types, this will miss identical pointer types, among others if c.typ != oc.typ { return false } if c.source != oc.source { return false } for i, v := range c.Values { if !v.(Constant).equal(oc.Values[i].(Constant)) { return false } } return true } func (c *ArrayConst) equal(o Constant) bool { oc, ok := o.(*ArrayConst) if !ok { return false } // TODO(dh): don't use == for types, this will miss identical pointer types, among others return c.typ == oc.typ && c.source == oc.source } func (c *GenericConst) equal(o Constant) bool { oc, ok := o.(*GenericConst) if !ok { return false } // TODO(dh): don't use == for types, this will miss identical pointer types, among others return c.typ == oc.typ && c.source == oc.source } golang-honnef-go-tools-2024.1/go/ir/create.go000066400000000000000000000175471465704072200207230ustar00rootroot00000000000000// Copyright 2013 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. package ir // This file implements the CREATE phase of IR construction. // See builder.go for explanation. import ( "fmt" "go/ast" "go/token" "go/types" "go/version" "os" "sync" "honnef.co/go/tools/go/types/typeutil" ) // measured on the standard library and rounded up to powers of two, // on average there are 8 blocks and 16 instructions per block in a // function. const avgBlocks = 8 const avgInstructionsPerBlock = 16 // NewProgram returns a new IR Program. // // mode controls diagnostics and checking during IR construction. func NewProgram(fset *token.FileSet, mode BuilderMode) *Program { prog := &Program{ Fset: fset, imported: make(map[string]*Package), packages: make(map[*types.Package]*Package), mode: mode, } h := typeutil.MakeHasher() // protected by methodsMu, in effect prog.methodSets.SetHasher(h) prog.canon.SetHasher(h) return prog } // memberFromObject populates package pkg with a member for the // typechecker object obj. // // For objects from Go source code, syntax is the associated syntax tree // (for funcs and vars only) and goversion defines the appropriate // interpretation; they will be used during the build phase. func memberFromObject(pkg *Package, obj types.Object, syntax ast.Node, goversion string) { name := obj.Name() switch obj := obj.(type) { case *types.Builtin: if pkg.Pkg != types.Unsafe { panic("unexpected builtin object: " + obj.String()) } case *types.TypeName: if name != "_" { pkg.Members[name] = &Type{ object: obj, pkg: pkg, } } case *types.Const: c := &NamedConst{ object: obj, Value: NewConst(obj.Val(), obj.Type(), syntax), pkg: pkg, } pkg.values[obj] = c.Value if name != "_" { pkg.Members[name] = c } case *types.Var: g := &Global{ Pkg: pkg, name: name, object: obj, typ: types.NewPointer(obj.Type()), // address } pkg.values[obj] = g if name != "_" { pkg.Members[name] = g } case *types.Func: sig := obj.Type().(*types.Signature) if sig.Recv() == nil && name == "init" { pkg.ninit++ name = fmt.Sprintf("init#%d", pkg.ninit) } fn := &Function{ name: name, object: obj, Signature: sig, Pkg: pkg, Prog: pkg.Prog, goversion: goversion, } fn.source = syntax fn.initHTML(pkg.printFunc) if syntax == nil { fn.Synthetic = SyntheticLoadedFromExportData } else { // Note: we initialize fn.Blocks in // (*builder).buildFunction and not here because Blocks // being nil is used to indicate that building of the // function hasn't started yet. fn.functionBody = &functionBody{ scratchInstructions: make([]Instruction, avgBlocks*avgInstructionsPerBlock), } } pkg.values[obj] = fn pkg.Functions = append(pkg.Functions, fn) if name != "_" && sig.Recv() == nil { pkg.Members[name] = fn // package-level function } default: // (incl. *types.Package) panic("unexpected Object type: " + obj.String()) } } // membersFromDecl populates package pkg with members for each // typechecker object (var, func, const or type) associated with the // specified decl. func membersFromDecl(pkg *Package, decl ast.Decl, goversion string) { switch decl := decl.(type) { case *ast.GenDecl: // import, const, type or var switch decl.Tok { case token.CONST: for _, spec := range decl.Specs { for _, id := range spec.(*ast.ValueSpec).Names { memberFromObject(pkg, pkg.info.Defs[id], nil, "") } } case token.VAR: for _, spec := range decl.Specs { for _, rhs := range spec.(*ast.ValueSpec).Values { pkg.initVersion[rhs] = goversion } for _, id := range spec.(*ast.ValueSpec).Names { memberFromObject(pkg, pkg.info.Defs[id], spec, goversion) } } case token.TYPE: for _, spec := range decl.Specs { id := spec.(*ast.TypeSpec).Name memberFromObject(pkg, pkg.info.Defs[id], nil, "") } } case *ast.FuncDecl: id := decl.Name obj, ok := pkg.info.Defs[id] if !ok { panic(fmt.Sprintf("couldn't find object for id %q at %s", id.Name, pkg.Prog.Fset.PositionFor(id.Pos(), false))) } if obj == nil { panic(fmt.Sprintf("found nil object for id %q at %s", id.Name, pkg.Prog.Fset.PositionFor(id.Pos(), false))) } memberFromObject(pkg, obj, decl, goversion) } } // CreatePackage constructs and returns an IR Package from the // specified type-checked, error-free file ASTs, and populates its // Members mapping. // // importable determines whether this package should be returned by a // subsequent call to ImportedPackage(pkg.Path()). // // The real work of building IR form for each function is not done // until a subsequent call to Package.Build(). func (prog *Program) CreatePackage(pkg *types.Package, files []*ast.File, info *types.Info, importable bool) *Package { p := &Package{ Prog: prog, Members: make(map[string]Member), values: make(map[types.Object]Value), Pkg: pkg, // transient values (CREATE and BUILD phases) info: info, files: files, printFunc: prog.PrintFunc, initVersion: make(map[ast.Expr]string), } // Add init() function. p.init = &Function{ name: "init", Signature: new(types.Signature), Synthetic: SyntheticPackageInitializer, Pkg: p, Prog: prog, functionBody: new(functionBody), goversion: "", // See Package.build for details. } p.init.initHTML(prog.PrintFunc) p.Members[p.init.name] = p.init p.Functions = append(p.Functions, p.init) // CREATE phase. // Allocate all package members: vars, funcs, consts and types. if len(files) > 0 { // Go source package. for _, file := range files { goversion := version.Lang(p.info.FileVersions[file]) for _, decl := range file.Decls { membersFromDecl(p, decl, goversion) } } } else { // GC-compiled binary package (or "unsafe") // No code. // No position information. scope := p.Pkg.Scope() for _, name := range scope.Names() { obj := scope.Lookup(name) memberFromObject(p, obj, nil, "") if obj, ok := obj.(*types.TypeName); ok { if named, ok := obj.Type().(*types.Named); ok { for i, n := 0, named.NumMethods(); i < n; i++ { memberFromObject(p, named.Method(i), nil, "") } } } } } // Add initializer guard variable. initguard := &Global{ Pkg: p, name: "init$guard", typ: types.NewPointer(tBool), } p.Members[initguard.Name()] = initguard if prog.mode&GlobalDebug != 0 { p.SetDebugMode(true) } if prog.mode&PrintPackages != 0 { printMu.Lock() p.WriteTo(os.Stdout) printMu.Unlock() } if importable { prog.imported[p.Pkg.Path()] = p } prog.packages[p.Pkg] = p return p } // printMu serializes printing of Packages/Functions to stdout. var printMu sync.Mutex // AllPackages returns a new slice containing all packages in the // program prog in unspecified order. func (prog *Program) AllPackages() []*Package { pkgs := make([]*Package, 0, len(prog.packages)) for _, pkg := range prog.packages { pkgs = append(pkgs, pkg) } return pkgs } // ImportedPackage returns the importable Package whose PkgPath // is path, or nil if no such Package has been created. // // A parameter to CreatePackage determines whether a package should be // considered importable. For example, no import declaration can resolve // to the ad-hoc main package created by 'go build foo.go'. // // TODO(adonovan): rethink this function and the "importable" concept; // most packages are importable. This function assumes that all // types.Package.Path values are unique within the ir.Program, which is // false---yet this function remains very convenient. // Clients should use (*Program).Package instead where possible. // IR doesn't really need a string-keyed map of packages. func (prog *Program) ImportedPackage(path string) *Package { return prog.imported[path] } golang-honnef-go-tools-2024.1/go/ir/doc.go000066400000000000000000000141151465704072200202110ustar00rootroot00000000000000// Copyright 2013 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. // Package ir defines a representation of the elements of Go programs // (packages, types, functions, variables and constants) using a // static single-information (SSI) form intermediate representation // (IR) for the bodies of functions. // // THIS INTERFACE IS EXPERIMENTAL AND IS LIKELY TO CHANGE. // // For an introduction to SSA form, upon which SSI builds, see // https://en.wikipedia.org/wiki/Static_single_assignment_form. // This page provides a broader reading list: // https://www.dcs.gla.ac.uk/~jsinger/ssa.html. // // For an introduction to SSI form, see The static single information // form by C. Scott Ananian. // // The level of abstraction of the IR form is intentionally close to // the source language to facilitate construction of source analysis // tools. It is not intended for machine code generation. // // The simplest way to create the IR of a package is // to load typed syntax trees using golang.org/x/tools/go/packages, then // invoke the irutil.Packages helper function. See ExampleLoadPackages // and ExampleWholeProgram for examples. // The resulting ir.Program contains all the packages and their // members, but IR code is not created for function bodies until a // subsequent call to (*Package).Build or (*Program).Build. // // The builder initially builds a naive IR form in which all local // variables are addresses of stack locations with explicit loads and // stores. Registerization of eligible locals and φ-node insertion // using dominance and dataflow are then performed as a second pass // called "lifting" to improve the accuracy and performance of // subsequent analyses; this pass can be skipped by setting the // NaiveForm builder flag. // // The primary interfaces of this package are: // // - Member: a named member of a Go package. // - Value: an expression that yields a value. // - Instruction: a statement that consumes values and performs computation. // - Node: a Value or Instruction (emphasizing its membership in the IR value graph) // // A computation that yields a result implements both the Value and // Instruction interfaces. The following table shows for each // concrete type which of these interfaces it implements. // // Value? Instruction? Member? // *Alloc ✔ ✔ // *BinOp ✔ ✔ // *BlankStore ✔ // *Builtin ✔ // *Call ✔ ✔ // *ChangeInterface ✔ ✔ // *ChangeType ✔ ✔ // *Const ✔ ✔ // *Convert ✔ ✔ // *DebugRef ✔ // *Defer ✔ ✔ // *Extract ✔ ✔ // *Field ✔ ✔ // *FieldAddr ✔ ✔ // *FreeVar ✔ // *Function ✔ ✔ (func) // *Global ✔ ✔ (var) // *Go ✔ ✔ // *If ✔ // *Index ✔ ✔ // *IndexAddr ✔ ✔ // *Jump ✔ // *Load ✔ ✔ // *MakeChan ✔ ✔ // *MakeClosure ✔ ✔ // *MakeInterface ✔ ✔ // *MakeMap ✔ ✔ // *MakeSlice ✔ ✔ // *MapLookup ✔ ✔ // *MapUpdate ✔ ✔ // *MultiConvert ✔ ✔ // *NamedConst ✔ (const) // *Next ✔ ✔ // *Panic ✔ // *Parameter ✔ ✔ // *Phi ✔ ✔ // *Range ✔ ✔ // *Recv ✔ ✔ // *Return ✔ // *RunDefers ✔ // *Select ✔ ✔ // *Send ✔ ✔ // *Sigma ✔ ✔ // *Slice ✔ ✔ // *SliceToArrayPointer ✔ ✔ // *SliceToArray ✔ ✔ // *Store ✔ ✔ // *StringLookup ✔ ✔ // *Type ✔ (type) // *TypeAssert ✔ ✔ // *UnOp ✔ ✔ // *Unreachable ✔ // // Other key types in this package include: Program, Package, Function // and BasicBlock. // // The program representation constructed by this package is fully // resolved internally, i.e. it does not rely on the names of Values, // Packages, Functions, Types or BasicBlocks for the correct // interpretation of the program. Only the identities of objects and // the topology of the IR and type graphs are semantically // significant. (There is one exception: Ids, used to identify field // and method names, contain strings.) Avoidance of name-based // operations simplifies the implementation of subsequent passes and // can make them very efficient. Many objects are nonetheless named // to aid in debugging, but it is not essential that the names be // either accurate or unambiguous. The public API exposes a number of // name-based maps for client convenience. // // The ir/irutil package provides various utilities that depend only // on the public API of this package. // // TODO(adonovan): Consider the exceptional control-flow implications // of defer and recover(). // // TODO(adonovan): write a how-to document for all the various cases // of trying to determine corresponding elements across the four // domains of source locations, ast.Nodes, types.Objects, // ir.Values/Instructions. package ir golang-honnef-go-tools-2024.1/go/ir/dom.go000066400000000000000000000272231465704072200202270ustar00rootroot00000000000000// Copyright 2013 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. package ir // This file defines algorithms related to dominance. // Dominator tree construction ---------------------------------------- // // We use the algorithm described in Lengauer & Tarjan. 1979. A fast // algorithm for finding dominators in a flowgraph. // https://doi.acm.org/10.1145/357062.357071 // // We also apply the optimizations to SLT described in Georgiadis et // al, Finding Dominators in Practice, JGAA 2006, // https://jgaa.info/accepted/2006/GeorgiadisTarjanWerneck2006.10.1.pdf // to avoid the need for buckets of size > 1. import ( "bytes" "fmt" "io" "math/big" "os" "sort" ) // Idom returns the block that immediately dominates b: // its parent in the dominator tree, if any. // The entry node (b.Index==0) does not have a parent. func (b *BasicBlock) Idom() *BasicBlock { return b.dom.idom } // Dominees returns the list of blocks that b immediately dominates: // its children in the dominator tree. func (b *BasicBlock) Dominees() []*BasicBlock { return b.dom.children } // Dominates reports whether b dominates c. func (b *BasicBlock) Dominates(c *BasicBlock) bool { return b.dom.pre <= c.dom.pre && c.dom.post <= b.dom.post } type byDomPreorder []*BasicBlock func (a byDomPreorder) Len() int { return len(a) } func (a byDomPreorder) Swap(i, j int) { a[i], a[j] = a[j], a[i] } func (a byDomPreorder) Less(i, j int) bool { return a[i].dom.pre < a[j].dom.pre } // DomPreorder returns a new slice containing the blocks of f in // dominator tree preorder. func (f *Function) DomPreorder() []*BasicBlock { n := len(f.Blocks) order := make(byDomPreorder, n) copy(order, f.Blocks) sort.Sort(order) return order } // domInfo contains a BasicBlock's dominance information. type domInfo struct { idom *BasicBlock // immediate dominator (parent in domtree) children []*BasicBlock // nodes immediately dominated by this one pre, post int32 // pre- and post-order numbering within domtree } // buildDomTree computes the dominator tree of f using the LT algorithm. // Precondition: all blocks are reachable (e.g. optimizeBlocks has been run). func buildDomTree(fn *Function) { // The step numbers refer to the original LT paper; the // reordering is due to Georgiadis. // Clear any previous domInfo. for _, b := range fn.Blocks { b.dom = domInfo{} } idoms := make([]*BasicBlock, len(fn.Blocks)) order := make([]*BasicBlock, 0, len(fn.Blocks)) seen := fn.blockset(0) var dfs func(b *BasicBlock) dfs = func(b *BasicBlock) { if !seen.Add(b) { return } for _, succ := range b.Succs { dfs(succ) } if fn.fakeExits.Has(b) { dfs(fn.Exit) } order = append(order, b) b.post = len(order) - 1 } dfs(fn.Blocks[0]) for i := 0; i < len(order)/2; i++ { o := len(order) - i - 1 order[i], order[o] = order[o], order[i] } idoms[fn.Blocks[0].Index] = fn.Blocks[0] changed := true for changed { changed = false // iterate over all nodes in reverse postorder, except for the // entry node for _, b := range order[1:] { var newIdom *BasicBlock do := func(p *BasicBlock) { if idoms[p.Index] == nil { return } if newIdom == nil { newIdom = p } else { finger1 := p finger2 := newIdom for finger1 != finger2 { for finger1.post < finger2.post { finger1 = idoms[finger1.Index] } for finger2.post < finger1.post { finger2 = idoms[finger2.Index] } } newIdom = finger1 } } for _, p := range b.Preds { do(p) } if b == fn.Exit { for _, p := range fn.Blocks { if fn.fakeExits.Has(p) { do(p) } } } if idoms[b.Index] != newIdom { idoms[b.Index] = newIdom changed = true } } } for i, b := range idoms { fn.Blocks[i].dom.idom = b if b == nil { // malformed CFG continue } if i == b.Index { continue } b.dom.children = append(b.dom.children, fn.Blocks[i]) } numberDomTree(fn.Blocks[0], 0, 0) // printDomTreeDot(os.Stderr, fn) // debugging // printDomTreeText(os.Stderr, root, 0) // debugging if fn.Prog.mode&SanityCheckFunctions != 0 { sanityCheckDomTree(fn) } } // buildPostDomTree is like buildDomTree, but builds the post-dominator tree instead. func buildPostDomTree(fn *Function) { // The step numbers refer to the original LT paper; the // reordering is due to Georgiadis. // Clear any previous domInfo. for _, b := range fn.Blocks { b.pdom = domInfo{} } idoms := make([]*BasicBlock, len(fn.Blocks)) order := make([]*BasicBlock, 0, len(fn.Blocks)) seen := fn.blockset(0) var dfs func(b *BasicBlock) dfs = func(b *BasicBlock) { if !seen.Add(b) { return } for _, pred := range b.Preds { dfs(pred) } if b == fn.Exit { for _, p := range fn.Blocks { if fn.fakeExits.Has(p) { dfs(p) } } } order = append(order, b) b.post = len(order) - 1 } dfs(fn.Exit) for i := 0; i < len(order)/2; i++ { o := len(order) - i - 1 order[i], order[o] = order[o], order[i] } idoms[fn.Exit.Index] = fn.Exit changed := true for changed { changed = false // iterate over all nodes in reverse postorder, except for the // exit node for _, b := range order[1:] { var newIdom *BasicBlock do := func(p *BasicBlock) { if idoms[p.Index] == nil { return } if newIdom == nil { newIdom = p } else { finger1 := p finger2 := newIdom for finger1 != finger2 { for finger1.post < finger2.post { finger1 = idoms[finger1.Index] } for finger2.post < finger1.post { finger2 = idoms[finger2.Index] } } newIdom = finger1 } } for _, p := range b.Succs { do(p) } if fn.fakeExits.Has(b) { do(fn.Exit) } if idoms[b.Index] != newIdom { idoms[b.Index] = newIdom changed = true } } } for i, b := range idoms { fn.Blocks[i].pdom.idom = b if b == nil { // malformed CFG continue } if i == b.Index { continue } b.pdom.children = append(b.pdom.children, fn.Blocks[i]) } numberPostDomTree(fn.Exit, 0, 0) // printPostDomTreeDot(os.Stderr, fn) // debugging // printPostDomTreeText(os.Stderr, fn.Exit, 0) // debugging if fn.Prog.mode&SanityCheckFunctions != 0 { // XXX sanityCheckDomTree(fn) // XXX } } // numberDomTree sets the pre- and post-order numbers of a depth-first // traversal of the dominator tree rooted at v. These are used to // answer dominance queries in constant time. func numberDomTree(v *BasicBlock, pre, post int32) (int32, int32) { v.dom.pre = pre pre++ for _, child := range v.dom.children { pre, post = numberDomTree(child, pre, post) } v.dom.post = post post++ return pre, post } // numberPostDomTree sets the pre- and post-order numbers of a depth-first // traversal of the post-dominator tree rooted at v. These are used to // answer post-dominance queries in constant time. func numberPostDomTree(v *BasicBlock, pre, post int32) (int32, int32) { v.pdom.pre = pre pre++ for _, child := range v.pdom.children { pre, post = numberPostDomTree(child, pre, post) } v.pdom.post = post post++ return pre, post } // Testing utilities ---------------------------------------- // sanityCheckDomTree checks the correctness of the dominator tree // computed by the LT algorithm by comparing against the dominance // relation computed by a naive Kildall-style forward dataflow // analysis (Algorithm 10.16 from the "Dragon" book). func sanityCheckDomTree(f *Function) { n := len(f.Blocks) // D[i] is the set of blocks that dominate f.Blocks[i], // represented as a bit-set of block indices. D := make([]big.Int, n) one := big.NewInt(1) // all is the set of all blocks; constant. var all big.Int all.Set(one).Lsh(&all, uint(n)).Sub(&all, one) // Initialization. for i := range f.Blocks { if i == 0 { // A root is dominated only by itself. D[i].SetBit(&D[0], 0, 1) } else { // All other blocks are (initially) dominated // by every block. D[i].Set(&all) } } // Iteration until fixed point. for changed := true; changed; { changed = false for i, b := range f.Blocks { if i == 0 { continue } // Compute intersection across predecessors. var x big.Int x.Set(&all) for _, pred := range b.Preds { x.And(&x, &D[pred.Index]) } if b == f.Exit { for _, p := range f.Blocks { if f.fakeExits.Has(p) { x.And(&x, &D[p.Index]) } } } x.SetBit(&x, i, 1) // a block always dominates itself. if D[i].Cmp(&x) != 0 { D[i].Set(&x) changed = true } } } // Check the entire relation. O(n^2). ok := true for i := 0; i < n; i++ { for j := 0; j < n; j++ { b, c := f.Blocks[i], f.Blocks[j] actual := b.Dominates(c) expected := D[j].Bit(i) == 1 if actual != expected { fmt.Fprintf(os.Stderr, "dominates(%s, %s)==%t, want %t\n", b, c, actual, expected) ok = false } } } preorder := f.DomPreorder() for _, b := range f.Blocks { if got := preorder[b.dom.pre]; got != b { fmt.Fprintf(os.Stderr, "preorder[%d]==%s, want %s\n", b.dom.pre, got, b) ok = false } } if !ok { panic("sanityCheckDomTree failed for " + f.String()) } } // Printing functions ---------------------------------------- // printDomTree prints the dominator tree as text, using indentation. // //lint:ignore U1000 used during debugging func printDomTreeText(buf *bytes.Buffer, v *BasicBlock, indent int) { fmt.Fprintf(buf, "%*s%s\n", 4*indent, "", v) for _, child := range v.dom.children { printDomTreeText(buf, child, indent+1) } } // printDomTreeDot prints the dominator tree of f in AT&T GraphViz // (.dot) format. // //lint:ignore U1000 used during debugging func printDomTreeDot(buf io.Writer, f *Function) { fmt.Fprintln(buf, "//", f) fmt.Fprintln(buf, "digraph domtree {") for i, b := range f.Blocks { v := b.dom fmt.Fprintf(buf, "\tn%d [label=\"%s (%d, %d)\",shape=\"rectangle\"];\n", v.pre, b, v.pre, v.post) // TODO(adonovan): improve appearance of edges // belonging to both dominator tree and CFG. // Dominator tree edge. if i != 0 { fmt.Fprintf(buf, "\tn%d -> n%d [style=\"solid\",weight=100];\n", v.idom.dom.pre, v.pre) } // CFG edges. for _, pred := range b.Preds { fmt.Fprintf(buf, "\tn%d -> n%d [style=\"dotted\",weight=0];\n", pred.dom.pre, v.pre) } if f.fakeExits.Has(b) { fmt.Fprintf(buf, "\tn%d -> n%d [style=\"dotted\",weight=0,color=red];\n", b.dom.pre, f.Exit.dom.pre) } } fmt.Fprintln(buf, "}") } // printDomTree prints the dominator tree as text, using indentation. // //lint:ignore U1000 used during debugging func printPostDomTreeText(buf io.Writer, v *BasicBlock, indent int) { fmt.Fprintf(buf, "%*s%s\n", 4*indent, "", v) for _, child := range v.pdom.children { printPostDomTreeText(buf, child, indent+1) } } // printDomTreeDot prints the dominator tree of f in AT&T GraphViz // (.dot) format. // //lint:ignore U1000 used during debugging func printPostDomTreeDot(buf io.Writer, f *Function) { fmt.Fprintln(buf, "//", f) fmt.Fprintln(buf, "digraph pdomtree {") for _, b := range f.Blocks { v := b.pdom fmt.Fprintf(buf, "\tn%d [label=\"%s (%d, %d)\",shape=\"rectangle\"];\n", v.pre, b, v.pre, v.post) // TODO(adonovan): improve appearance of edges // belonging to both dominator tree and CFG. // Dominator tree edge. if b != f.Exit { fmt.Fprintf(buf, "\tn%d -> n%d [style=\"solid\",weight=100];\n", v.idom.pdom.pre, v.pre) } // CFG edges. for _, pred := range b.Preds { fmt.Fprintf(buf, "\tn%d -> n%d [style=\"dotted\",weight=0];\n", pred.pdom.pre, v.pre) } if f.fakeExits.Has(b) { fmt.Fprintf(buf, "\tn%d -> n%d [style=\"dotted\",weight=0,color=red];\n", b.dom.pre, f.Exit.dom.pre) } } fmt.Fprintln(buf, "}") } golang-honnef-go-tools-2024.1/go/ir/emit.go000066400000000000000000000440211465704072200204010ustar00rootroot00000000000000// Copyright 2013 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. package ir // Helpers for emitting IR instructions. import ( "fmt" "go/ast" "go/constant" "go/token" "go/types" "honnef.co/go/tools/go/types/typeutil" "golang.org/x/exp/typeparams" ) // emitAlloc emits to f a new Alloc instruction allocating a variable // of type typ. // // The caller must set Alloc.Heap=true (for a heap-allocated variable) // or add the Alloc to f.Locals (for a frame-allocated variable). // // During building, a variable in f.Locals may have its Heap flag // set when it is discovered that its address is taken. // These Allocs are removed from f.Locals at the end. // // The builder should generally call one of the emit{New,Local,LocalVar} wrappers instead. func emitAlloc(f *Function, typ types.Type, source ast.Node, comment string) *Alloc { v := &Alloc{} v.comment = comment v.setType(types.NewPointer(typ)) f.emit(v, source) return v } // emitNew emits to f a new Alloc instruction heap-allocating a // variable of type typ. func emitNew(f *Function, typ types.Type, source ast.Node, comment string) *Alloc { alloc := emitAlloc(f, typ, source, comment) alloc.Heap = true return alloc } // emitLocal creates a local var for (t, source, comment) and // emits an Alloc instruction for it. // // (Use this function or emitNew for synthetic variables; // for source-level variables, use emitLocalVar.) func emitLocal(f *Function, t types.Type, source ast.Node, comment string) *Alloc { local := emitAlloc(f, t, source, comment) f.Locals = append(f.Locals, local) return local } // emitLocalVar creates a local var for v and emits an Alloc instruction for it. // Subsequent calls to f.lookup(v) return it. func emitLocalVar(f *Function, v *types.Var, source ast.Node) *Alloc { alloc := emitLocal(f, v.Type(), source, v.Name()) f.vars[v] = alloc return alloc } // emitLoad emits to f an instruction to load the address addr into a // new temporary, and returns the value so defined. func emitLoad(f *Function, addr Value, source ast.Node) *Load { v := &Load{X: addr} v.setType(deref(addr.Type())) f.emit(v, source) return v } func emitRecv(f *Function, ch Value, commaOk bool, typ types.Type, source ast.Node) Value { recv := &Recv{ Chan: ch, CommaOk: commaOk, } recv.setType(typ) return f.emit(recv, source) } // emitDebugRef emits to f a DebugRef pseudo-instruction associating // expression e with value v. func emitDebugRef(f *Function, e ast.Expr, v Value, isAddr bool) { ref := makeDebugRef(f, e, v, isAddr) if ref == nil { return } f.emit(ref, nil) } func makeDebugRef(f *Function, e ast.Expr, v Value, isAddr bool) *DebugRef { if !f.debugInfo() { return nil // debugging not enabled } if v == nil || e == nil { panic("nil") } var obj types.Object e = unparen(e) if id, ok := e.(*ast.Ident); ok { if isBlankIdent(id) { return nil } obj = f.Pkg.objectOf(id) switch obj.(type) { case *types.Nil, *types.Const, *types.Builtin: return nil } } return &DebugRef{ X: v, Expr: e, IsAddr: isAddr, object: obj, } } // emitArith emits to f code to compute the binary operation op(x, y) // where op is an eager shift, logical or arithmetic operation. // (Use emitCompare() for comparisons and Builder.logicalBinop() for // non-eager operations.) func emitArith(f *Function, op token.Token, x, y Value, t types.Type, source ast.Node) Value { switch op { case token.SHL, token.SHR: x = emitConv(f, x, t, source) // y may be signed or an 'untyped' constant. // There is a runtime panic if y is signed and <0. Instead of inserting a check for y<0 // and converting to an unsigned value (like the compiler) leave y as is. if b, ok := y.Type().Underlying().(*types.Basic); ok && b.Info()&types.IsUntyped != 0 { // Untyped conversion: // Spec https://go.dev/ref/spec#Operators: // The right operand in a shift expression must have integer type or be an untyped constant // representable by a value of type uint. y = emitConv(f, y, types.Typ[types.Uint], source) } case token.ADD, token.SUB, token.MUL, token.QUO, token.REM, token.AND, token.OR, token.XOR, token.AND_NOT: x = emitConv(f, x, t, source) y = emitConv(f, y, t, source) default: panic("illegal op in emitArith: " + op.String()) } v := &BinOp{ Op: op, X: x, Y: y, } v.setType(t) return f.emit(v, source) } // emitCompare emits to f code compute the boolean result of // comparison comparison 'x op y'. func emitCompare(f *Function, op token.Token, x, y Value, source ast.Node) Value { xt := x.Type().Underlying() yt := y.Type().Underlying() // Special case to optimise a tagless SwitchStmt so that // these are equivalent // switch { case e: ...} // switch true { case e: ... } // if e==true { ... } // even in the case when e's type is an interface. // TODO(adonovan): opt: generalise to x==true, false!=y, etc. if x, ok := x.(*Const); ok && op == token.EQL && x.Value != nil && x.Value.Kind() == constant.Bool && constant.BoolVal(x.Value) { if yt, ok := yt.(*types.Basic); ok && yt.Info()&types.IsBoolean != 0 { return y } } if types.Identical(xt, yt) { // no conversion necessary } else if _, ok := xt.(*types.Interface); ok && !typeparams.IsTypeParam(x.Type()) { y = emitConv(f, y, x.Type(), source) } else if _, ok := yt.(*types.Interface); ok && !typeparams.IsTypeParam(y.Type()) { x = emitConv(f, x, y.Type(), source) } else if _, ok := x.(*Const); ok { x = emitConv(f, x, y.Type(), source) } else if _, ok := y.(*Const); ok { y = emitConv(f, y, x.Type(), source) //lint:ignore SA9003 no-op } else { // other cases, e.g. channels. No-op. } v := &BinOp{ Op: op, X: x, Y: y, } v.setType(tBool) return f.emit(v, source) } // isValuePreserving returns true if a conversion from ut_src to // ut_dst is value-preserving, i.e. just a change of type. // Precondition: neither argument is a named type. func isValuePreserving(ut_src, ut_dst types.Type) bool { // Identical underlying types? if types.IdenticalIgnoreTags(ut_dst, ut_src) { return true } switch ut_dst.(type) { case *types.Chan: // Conversion between channel types? _, ok := ut_src.(*types.Chan) return ok case *types.Pointer: // Conversion between pointers with identical base types? _, ok := ut_src.(*types.Pointer) return ok } return false } // emitConv emits to f code to convert Value val to exactly type typ, // and returns the converted value. Implicit conversions are required // by language assignability rules in assignments, parameter passing, // etc. func emitConv(f *Function, val Value, t_dst types.Type, source ast.Node) Value { t_src := val.Type() // Identical types? Conversion is a no-op. if types.Identical(t_src, t_dst) { return val } ut_dst := t_dst.Underlying() ut_src := t_src.Underlying() // Conversion to, or construction of a value of, an interface type? if isNonTypeParamInterface(t_dst) { // Interface name change? if isValuePreserving(ut_src, ut_dst) { c := &ChangeType{X: val} c.setType(t_dst) return f.emit(c, source) } // Assignment from one interface type to another? if isNonTypeParamInterface(t_src) { c := &ChangeInterface{X: val} c.setType(t_dst) return f.emit(c, source) } // Untyped nil constant? Return interface-typed nil constant. if ut_src == tUntypedNil { return emitConst(f, zeroConst(t_dst, source)) } // Convert (non-nil) "untyped" literals to their default type. if t, ok := ut_src.(*types.Basic); ok && t.Info()&types.IsUntyped != 0 { val = emitConv(f, val, types.Default(ut_src), source) } f.Pkg.Prog.needMethodsOf(val.Type()) mi := &MakeInterface{X: val} mi.setType(t_dst) return f.emit(mi, source) } // In the common case, the typesets of src and dst are singletons // and we emit an appropriate conversion. But if either contains // a type parameter, the conversion may represent a cross product, // in which case which we emit a MultiConvert. tset_dst := typeutil.NewTypeSet(ut_dst) tset_src := typeutil.NewTypeSet(ut_src) // conversionCase describes an instruction pattern that may be emitted to // model d <- s for d in dst_terms and s in src_terms. // Multiple conversions can match the same pattern. type conversionCase uint8 const ( changeType conversionCase = 1 << iota sliceToArray sliceToArrayPtr sliceTo0Array sliceTo0ArrayPtr convert ) classify := func(s, d types.Type) conversionCase { // Just a change of type, but not value or representation? if isValuePreserving(s, d) { return changeType } // Conversion from slice to array or slice to array pointer? if slice, ok := s.(*types.Slice); ok { var arr *types.Array var ptr bool // Conversion from slice to array pointer? switch d := d.(type) { case *types.Array: arr = d case *types.Pointer: arr, _ = d.Elem().Underlying().(*types.Array) ptr = true } if arr != nil && types.Identical(slice.Elem(), arr.Elem()) { if arr.Len() == 0 { if ptr { return sliceTo0ArrayPtr } else { return sliceTo0Array } } if ptr { return sliceToArrayPtr } else { return sliceToArray } } } // The only remaining case in well-typed code is a representation- // changing conversion of basic types (possibly with []byte/[]rune). if !isBasic(s) && !isBasic(d) { panic(fmt.Sprintf("in %s: cannot convert term %s (%s [within %s]) to type %s [within %s]", f, val, val.Type(), s, t_dst, d)) } return convert } var classifications conversionCase for _, s := range tset_src.Terms { us := s.Type().Underlying() for _, d := range tset_dst.Terms { ud := d.Type().Underlying() classifications |= classify(us, ud) } } if classifications == 0 { panic(fmt.Sprintf("in %s: cannot convert %s (%s) to %s", f, val, val.Type(), t_dst)) } // Conversion of a compile-time constant value? if c, ok := val.(*Const); ok { // Conversion to a basic type? if isBasic(ut_dst) { // Conversion of a compile-time constant to // another constant type results in a new // constant of the destination type and // (initially) the same abstract value. // We don't truncate the value yet. return emitConst(f, NewConst(c.Value, t_dst, source)) } // Can we always convert from zero value without panicking? const mayPanic = sliceToArray | sliceToArrayPtr if c.Value == nil && classifications&mayPanic == 0 { return emitConst(f, NewConst(nil, t_dst, source)) } // We're converting from constant to non-constant type, // e.g. string -> []byte/[]rune. } switch classifications { case changeType: // representation-preserving change c := &ChangeType{X: val} c.setType(t_dst) return f.emit(c, source) case sliceToArrayPtr, sliceTo0ArrayPtr: // slice to array pointer c := &SliceToArrayPointer{X: val} c.setType(t_dst) return f.emit(c, source) case sliceToArray: // slice to arrays (not zero-length) p := &SliceToArray{X: val} p.setType(t_dst) return f.emit(p, source) case sliceTo0Array: // slice to zero-length arrays (constant) return emitConst(f, zeroConst(t_dst, source)) case convert: // representation-changing conversion c := &Convert{X: val} c.setType(t_dst) return f.emit(c, source) default: // multiple conversion c := &MultiConvert{X: val, from: tset_src, to: tset_dst} c.setType(t_dst) return f.emit(c, source) } } // emitStore emits to f an instruction to store value val at location // addr, applying implicit conversions as required by assignability rules. func emitStore(f *Function, addr, val Value, source ast.Node) *Store { s := &Store{ Addr: addr, Val: emitConv(f, val, deref(addr.Type()), source), } f.emit(s, source) return s } // emitJump emits to f a jump to target, and updates the control-flow graph. // Postcondition: f.currentBlock is nil. func emitJump(f *Function, target *BasicBlock, source ast.Node) *Jump { b := f.currentBlock j := new(Jump) b.emit(j, source) addEdge(b, target) f.currentBlock = nil return j } // emitIf emits to f a conditional jump to tblock or fblock based on // cond, and updates the control-flow graph. // Postcondition: f.currentBlock is nil. func emitIf(f *Function, cond Value, tblock, fblock *BasicBlock, source ast.Node) *If { b := f.currentBlock stmt := &If{Cond: cond} b.emit(stmt, source) addEdge(b, tblock) addEdge(b, fblock) f.currentBlock = nil return stmt } // emitExtract emits to f an instruction to extract the index'th // component of tuple. It returns the extracted value. func emitExtract(f *Function, tuple Value, index int, source ast.Node) Value { e := &Extract{Tuple: tuple, Index: index} e.setType(tuple.Type().(*types.Tuple).At(index).Type()) return f.emit(e, source) } // emitTypeAssert emits to f a type assertion value := x.(t) and // returns the value. x.Type() must be an interface. func emitTypeAssert(f *Function, x Value, t types.Type, source ast.Node) Value { a := &TypeAssert{X: x, AssertedType: t} a.setType(t) return f.emit(a, source) } // emitTypeTest emits to f a type test value,ok := x.(t) and returns // a (value, ok) tuple. x.Type() must be an interface. func emitTypeTest(f *Function, x Value, t types.Type, source ast.Node) Value { a := &TypeAssert{ X: x, AssertedType: t, CommaOk: true, } a.setType(types.NewTuple( newVar("value", t), varOk, )) return f.emit(a, source) } // emitTailCall emits to f a function call in tail position. The // caller is responsible for all fields of 'call' except its type. // Intended for wrapper methods. // Precondition: f does/will not use deferred procedure calls. // Postcondition: f.currentBlock is nil. func emitTailCall(f *Function, call *Call, source ast.Node) { tresults := f.Signature.Results() nr := tresults.Len() if nr == 1 { call.typ = tresults.At(0).Type() } else { call.typ = tresults } tuple := f.emit(call, source) var ret Return switch nr { case 0: // no-op case 1: ret.Results = []Value{tuple} default: for i := 0; i < nr; i++ { v := emitExtract(f, tuple, i, source) // TODO(adonovan): in principle, this is required: // v = emitConv(f, o.Type, f.Signature.Results[i].Type) // but in practice emitTailCall is only used when // the types exactly match. ret.Results = append(ret.Results, v) } } f.Exit = f.newBasicBlock("exit") emitJump(f, f.Exit, source) f.currentBlock = f.Exit f.emit(&ret, source) f.currentBlock = nil } // emitImplicitSelections emits to f code to apply the sequence of // implicit field selections specified by indices to base value v, and // returns the selected value. // // If v is the address of a struct, the result will be the address of // a field; if it is the value of a struct, the result will be the // value of a field. func emitImplicitSelections(f *Function, v Value, indices []int, source ast.Node) Value { for _, index := range indices { // We may have a generic type containing a pointer, or a pointer to a generic type containing a struct. A // pointer to a generic containing a pointer to a struct shouldn't be possible because the outer pointer gets // dereferenced implicitly before we get here. fld := typeutil.CoreType(deref(v.Type())).Underlying().(*types.Struct).Field(index) if isPointer(v.Type()) { instr := &FieldAddr{ X: v, Field: index, } instr.setType(types.NewPointer(fld.Type())) v = f.emit(instr, source) // Load the field's value iff indirectly embedded. if isPointer(fld.Type()) { v = emitLoad(f, v, source) } } else { instr := &Field{ X: v, Field: index, } instr.setType(fld.Type()) v = f.emit(instr, source) } } return v } // emitFieldSelection emits to f code to select the index'th field of v. // // If wantAddr, the input must be a pointer-to-struct and the result // will be the field's address; otherwise the result will be the // field's value. // Ident id is used for position and debug info. func emitFieldSelection(f *Function, v Value, index int, wantAddr bool, id *ast.Ident) Value { // We may have a generic type containing a pointer, or a pointer to a generic type containing a struct. A // pointer to a generic containing a pointer to a struct shouldn't be possible because the outer pointer gets // dereferenced implicitly before we get here. vut := typeutil.CoreType(deref(v.Type())).Underlying().(*types.Struct) fld := vut.Field(index) if isPointer(v.Type()) { instr := &FieldAddr{ X: v, Field: index, } instr.setSource(id) instr.setType(types.NewPointer(fld.Type())) v = f.emit(instr, id) // Load the field's value iff we don't want its address. if !wantAddr { v = emitLoad(f, v, id) } } else { instr := &Field{ X: v, Field: index, } instr.setSource(id) instr.setType(fld.Type()) v = f.emit(instr, id) } emitDebugRef(f, id, v, wantAddr) return v } // zeroValue emits to f code to produce a zero value of type t, // and returns it. func zeroValue(f *Function, t types.Type, source ast.Node) Value { return emitConst(f, zeroConst(t, source)) } type constKey struct { typ types.Type value constant.Value source ast.Node } func emitConst(f *Function, c Constant) Constant { if f.consts == nil { f.consts = map[constKey]constValue{} } typ := c.Type() var val constant.Value switch c := c.(type) { case *Const: val = c.Value case *ArrayConst, *GenericConst: // These can only represent zero values, so all we need is the type case *AggregateConst: candidates, _ := f.aggregateConsts.At(c.typ) for _, candidate := range candidates { if c.equal(candidate) { return candidate } } for i := range c.Values { c.Values[i] = emitConst(f, c.Values[i].(Constant)) } c.setBlock(f.Blocks[0]) rands := c.Operands(nil) updateOperandsReferrers(c, rands) candidates = append(candidates, c) f.aggregateConsts.Set(c.typ, candidates) return c default: panic(fmt.Sprintf("unexpected type %T", c)) } k := constKey{ typ: typ, value: val, source: c.Source(), } dup, ok := f.consts[k] if ok { return dup.c } else { c.setBlock(f.Blocks[0]) f.consts[k] = constValue{ c: c, idx: len(f.consts), } rands := c.Operands(nil) updateOperandsReferrers(c, rands) return c } } golang-honnef-go-tools-2024.1/go/ir/example_test.go000066400000000000000000000122651465704072200221420ustar00rootroot00000000000000// Copyright 2013 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. package ir_test import ( "bytes" "fmt" "go/ast" "go/importer" "go/parser" "go/token" "go/types" "log" "os" "strings" "honnef.co/go/tools/go/ir" "honnef.co/go/tools/go/ir/irutil" "golang.org/x/tools/go/packages" ) const hello = ` package main import "fmt" const message = "Hello, World!" func main() { fmt.Println(message) } ` // This program demonstrates how to run the IR builder on a single // package of one or more already-parsed files. Its dependencies are // loaded from compiler export data. This is what you'd typically use // for a compiler; it does not depend on golang.org/x/tools/go/loader. // // It shows the printed representation of packages, functions, and // instructions. Within the function listing, the name of each // BasicBlock such as ".0.entry" is printed left-aligned, followed by // the block's Instructions. // // For each instruction that defines an IR virtual register // (i.e. implements Value), the type of that value is shown in the // right column. // // Build and run the irdump.go program if you want a standalone tool // with similar functionality. It is located at // honnef.co/go/tools/internal/cmd/irdump. func Example_buildPackage() { // Parse the source files. fset := token.NewFileSet() f, err := parser.ParseFile(fset, "hello.go", hello, parser.ParseComments|parser.SkipObjectResolution) if err != nil { fmt.Print(err) // parse error return } files := []*ast.File{f} // Create the type-checker's package. pkg := types.NewPackage("hello", "") // Type-check the package, load dependencies. // Create and build the IR program. hello, _, err := irutil.BuildPackage( &types.Config{Importer: importer.Default()}, fset, pkg, files, ir.SanityCheckFunctions) if err != nil { fmt.Print(err) // type error in some package return } // Print out the package. hello.WriteTo(os.Stdout) // Print out the package-level functions. // Replace interface{} with any so the tests work for Go 1.17 and Go 1.18. { var buf bytes.Buffer ir.WriteFunction(&buf, hello.Func("init")) fmt.Print(strings.ReplaceAll(buf.String(), "interface{}", "any")) } { var buf bytes.Buffer ir.WriteFunction(&buf, hello.Func("main")) fmt.Print(strings.ReplaceAll(buf.String(), "interface{}", "any")) } // Output: // package hello: // func init func() // var init$guard bool // func main func() // const message message = Const {"Hello, World!"} // // # Name: hello.init // # Package: hello // # Synthetic: package initializer // func init(): // b0: # entry // t1 = Const {true} // t2 = Load init$guard // If t2 → b1 b2 // // b1: ← b0 b2 # exit // Return // // b2: ← b0 # init.start // Store {bool} init$guard t1 // t6 = Call <()> fmt.init // Jump → b1 // // # Name: hello.main // # Package: hello // # Location: hello.go:8:1 // func main(): // b0: # entry // t1 = Const {"Hello, World!"} // t2 = Const {0} // t3 = HeapAlloc <*[1]any> # varargs // t4 = IndexAddr <*any> t3 t2 // t5 = MakeInterface t1 // Store {any} t4 t5 // t7 = Slice <[]any> t3 // t8 = Call <(n int, err error)> fmt.Println t7 // Jump → b1 // // b1: ← b0 # exit // Return } // This example builds IR code for a set of packages using the // x/tools/go/packages API. This is what you would typically use for a // analysis capable of operating on a single package. func Example_loadPackages() { // Load, parse, and type-check the initial packages. cfg := &packages.Config{Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles | packages.NeedImports | packages.NeedTypes | packages.NeedTypesSizes | packages.NeedSyntax | packages.NeedTypesInfo} initial, err := packages.Load(cfg, "fmt", "net/http") if err != nil { log.Fatal(err) } // Stop if any package had errors. // This step is optional; without it, the next step // will create IR for only a subset of packages. if packages.PrintErrors(initial) > 0 { log.Fatalf("packages contain errors") } // Create IR packages for all well-typed packages. prog, pkgs := irutil.Packages(initial, ir.PrintPackages, nil) _ = prog // Build IR code for the well-typed initial packages. for _, p := range pkgs { if p != nil { p.Build() } } } // This example builds IR code for a set of packages plus all their dependencies, // using the x/tools/go/packages API. // This is what you'd typically use for a whole-program analysis. func Example_loadWholeProgram() { // Load, parse, and type-check the whole program. cfg := packages.Config{Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles | packages.NeedImports | packages.NeedTypes | packages.NeedTypesSizes | packages.NeedSyntax | packages.NeedTypesInfo | packages.NeedDeps} initial, err := packages.Load(&cfg, "fmt", "net/http") if err != nil { log.Fatal(err) } // Create IR packages for well-typed packages and their dependencies. prog, pkgs := irutil.AllPackages(initial, ir.PrintPackages, nil) _ = pkgs // Build IR code for the whole program. prog.Build() } golang-honnef-go-tools-2024.1/go/ir/exits.go000066400000000000000000000243641465704072200206070ustar00rootroot00000000000000package ir import ( "go/types" ) func (b *builder) buildExits(fn *Function) { if obj := fn.Object(); obj != nil { switch obj.Pkg().Path() { case "runtime": switch obj.Name() { case "exit": fn.NoReturn = AlwaysExits return case "throw": fn.NoReturn = AlwaysExits return case "Goexit": fn.NoReturn = AlwaysUnwinds return } case "go.uber.org/zap": switch obj.(*types.Func).FullName() { case "(*go.uber.org/zap.Logger).Fatal", "(*go.uber.org/zap.SugaredLogger).Fatal", "(*go.uber.org/zap.SugaredLogger).Fatalw", "(*go.uber.org/zap.SugaredLogger).Fatalf": // Technically, this method does not unconditionally exit // the process. It dynamically calls a function stored in // the logger. If the function is nil, it defaults to // os.Exit. // // The main intent of this method is to terminate the // process, and that's what the vast majority of people // will use it for. We'll happily accept some false // negatives to avoid a lot of false positives. fn.NoReturn = AlwaysExits case "(*go.uber.org/zap.Logger).Panic", "(*go.uber.org/zap.SugaredLogger).Panicw", "(*go.uber.org/zap.SugaredLogger).Panicf": fn.NoReturn = AlwaysUnwinds return case "(*go.uber.org/zap.Logger).DPanic", "(*go.uber.org/zap.SugaredLogger).DPanicf", "(*go.uber.org/zap.SugaredLogger).DPanicw": // These methods will only panic in development. } case "github.com/sirupsen/logrus": switch obj.(*types.Func).FullName() { case "(*github.com/sirupsen/logrus.Logger).Exit": // Technically, this method does not unconditionally exit // the process. It dynamically calls a function stored in // the logger. If the function is nil, it defaults to // os.Exit. // // The main intent of this method is to terminate the // process, and that's what the vast majority of people // will use it for. We'll happily accept some false // negatives to avoid a lot of false positives. fn.NoReturn = AlwaysExits return case "(*github.com/sirupsen/logrus.Logger).Panic", "(*github.com/sirupsen/logrus.Logger).Panicf", "(*github.com/sirupsen/logrus.Logger).Panicln": // These methods will always panic, but that's not // statically known from the code alone, because they // take a detour through the generic Log methods. fn.NoReturn = AlwaysUnwinds return case "(*github.com/sirupsen/logrus.Entry).Panicf", "(*github.com/sirupsen/logrus.Entry).Panicln": // Entry.Panic has an explicit panic, but Panicf and // Panicln do not, relying fully on the generic Log // method. fn.NoReturn = AlwaysUnwinds return case "(*github.com/sirupsen/logrus.Logger).Log", "(*github.com/sirupsen/logrus.Logger).Logf", "(*github.com/sirupsen/logrus.Logger).Logln": // TODO(dh): we cannot handle these cases. Whether they // exit or unwind depends on the level, which is set // via the first argument. We don't currently support // call-site-specific exit information. } case "github.com/golang/glog": switch obj.(*types.Func).FullName() { case "github.com/golang/glog.Exit", "github.com/golang/glog.ExitDepth", "github.com/golang/glog.Exitf", "github.com/golang/glog.Exitln", "github.com/golang/glog.Fatal", "github.com/golang/glog.FatalDepth", "github.com/golang/glog.Fatalf", "github.com/golang/glog.Fatalln": // all of these call os.Exit after logging fn.NoReturn = AlwaysExits } case "k8s.io/klog": switch obj.(*types.Func).FullName() { case "k8s.io/klog.Exit", "k8s.io/klog.ExitDepth", "k8s.io/klog.Exitf", "k8s.io/klog.Exitln", "k8s.io/klog.Fatal", "k8s.io/klog.FatalDepth", "k8s.io/klog.Fatalf", "k8s.io/klog.Fatalln": // all of these call os.Exit after logging fn.NoReturn = AlwaysExits } case "k8s.io/klog/v2": switch obj.(*types.Func).FullName() { case "k8s.io/klog/v2.Exit", "k8s.io/klog/v2.ExitDepth", "k8s.io/klog/v2.Exitf", "k8s.io/klog/v2.Exitln", "k8s.io/klog/v2.Fatal", "k8s.io/klog/v2.FatalDepth", "k8s.io/klog/v2.Fatalf", "k8s.io/klog/v2.Fatalln": // all of these call os.Exit after logging fn.NoReturn = AlwaysExits } } } isRecoverCall := func(instr Instruction) bool { if instr, ok := instr.(*Call); ok { if builtin, ok := instr.Call.Value.(*Builtin); ok { if builtin.Name() == "recover" { return true } } } return false } both := NewBlockSet(len(fn.Blocks)) exits := NewBlockSet(len(fn.Blocks)) unwinds := NewBlockSet(len(fn.Blocks)) recovers := false for _, u := range fn.Blocks { for _, instr := range u.Instrs { instrSwitch: switch instr := instr.(type) { case *Defer: if recovers { // avoid doing extra work, we already know that this function calls recover continue } call := instr.Call.StaticCallee() if call == nil { // not a static call, so we can't be sure the // deferred call isn't calling recover recovers = true break } if call.Package() == fn.Package() { b.buildFunction(call) } if len(call.Blocks) == 0 { // external function, we don't know what's // happening inside it // // TODO(dh): this includes functions from // imported packages, due to how go/analysis // works. We could introduce another fact, // like we've done for exiting and unwinding. recovers = true break } for _, y := range call.Blocks { for _, instr2 := range y.Instrs { if isRecoverCall(instr2) { recovers = true break instrSwitch } } } case *Panic: both.Add(u) unwinds.Add(u) case CallInstruction: switch instr.(type) { case *Defer, *Call: default: continue } if instr.Common().IsInvoke() { // give up return } var call *Function switch instr.Common().Value.(type) { case *Function, *MakeClosure: call = instr.Common().StaticCallee() case *Builtin: // the only builtins that affect control flow are // panic and recover, and we've already handled // those continue default: // dynamic dispatch return } // buildFunction is idempotent. if we're part of a // (mutually) recursive call chain, then buildFunction // will immediately return, and fn.WillExit will be false. if call.Package() == fn.Package() { b.buildFunction(call) } switch call.NoReturn { case AlwaysExits: both.Add(u) exits.Add(u) case AlwaysUnwinds: both.Add(u) unwinds.Add(u) case NeverReturns: both.Add(u) } } } } // depth-first search trying to find a path to the exit block that // doesn't cross any of the blacklisted blocks seen := NewBlockSet(len(fn.Blocks)) var findPath func(root *BasicBlock, bl *BlockSet) bool findPath = func(root *BasicBlock, bl *BlockSet) bool { if root == fn.Exit { return true } if seen.Has(root) { return false } if bl.Has(root) { return false } seen.Add(root) for _, succ := range root.Succs { if findPath(succ, bl) { return true } } return false } findPathEntry := func(root *BasicBlock, bl *BlockSet) bool { if bl.Num() == 0 { return true } seen.Clear() return findPath(root, bl) } if !findPathEntry(fn.Blocks[0], exits) { fn.NoReturn = AlwaysExits } else if !recovers { // Only consider unwinding and "never returns" if we don't // call recover. If we do call recover, then panics don't // bubble up the stack. // TODO(dh): the position of the defer matters. If we // unconditionally terminate before we defer a recover, then // the recover is ineffective. if !findPathEntry(fn.Blocks[0], unwinds) { fn.NoReturn = AlwaysUnwinds } else if !findPathEntry(fn.Blocks[0], both) { fn.NoReturn = NeverReturns } } } func (b *builder) addUnreachables(fn *Function) { var unreachable *BasicBlock for _, bb := range fn.Blocks { instrLoop: for i, instr := range bb.Instrs { if instr, ok := instr.(*Call); ok { var call *Function switch v := instr.Common().Value.(type) { case *Function: call = v case *MakeClosure: call = v.Fn.(*Function) } if call == nil { continue } if call.Package() == fn.Package() { // make sure we have information on all functions in this package b.buildFunction(call) } switch call.NoReturn { case AlwaysExits: // This call will cause the process to terminate. // Remove remaining instructions in the block and // replace any control flow with Unreachable. for _, succ := range bb.Succs { succ.removePred(bb) } bb.Succs = bb.Succs[:0] bb.Instrs = bb.Instrs[:i+1] bb.emit(new(Unreachable), instr.Source()) addEdge(bb, fn.Exit) break instrLoop case AlwaysUnwinds: // This call will cause the goroutine to terminate // and defers to run (i.e. a panic or // runtime.Goexit). Remove remaining instructions // in the block and replace any control flow with // an unconditional jump to the exit block. for _, succ := range bb.Succs { succ.removePred(bb) } bb.Succs = bb.Succs[:0] bb.Instrs = bb.Instrs[:i+1] bb.emit(new(Jump), instr.Source()) addEdge(bb, fn.Exit) break instrLoop case NeverReturns: // This call will either cause the goroutine to // terminate, or the process to terminate. Remove // remaining instructions in the block and replace // any control flow with a conditional jump to // either the exit block, or Unreachable. for _, succ := range bb.Succs { succ.removePred(bb) } bb.Succs = bb.Succs[:0] bb.Instrs = bb.Instrs[:i+1] var c Call c.Call.Value = &Builtin{ name: "ir:noreturnWasPanic", sig: types.NewSignatureType(nil, nil, nil, types.NewTuple(), types.NewTuple(anonVar(types.Typ[types.Bool])), false, ), } c.setType(types.Typ[types.Bool]) if unreachable == nil { unreachable = fn.newBasicBlock("unreachable") unreachable.emit(&Unreachable{}, nil) addEdge(unreachable, fn.Exit) } bb.emit(&c, instr.Source()) bb.emit(&If{Cond: &c}, instr.Source()) addEdge(bb, fn.Exit) addEdge(bb, unreachable) break instrLoop } } } } } golang-honnef-go-tools-2024.1/go/ir/func.go000066400000000000000000000710541465704072200204040ustar00rootroot00000000000000// Copyright 2013 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. package ir // This file implements the Function and BasicBlock types. import ( "bytes" "fmt" "go/ast" "go/format" "go/token" "go/types" "io" "os" "sort" "strings" "honnef.co/go/tools/go/types/typeutil" ) // addEdge adds a control-flow graph edge from from to to. func addEdge(from, to *BasicBlock) { from.Succs = append(from.Succs, to) to.Preds = append(to.Preds, from) } // Control returns the last instruction in the block. func (b *BasicBlock) Control() Instruction { if len(b.Instrs) == 0 { return nil } return b.Instrs[len(b.Instrs)-1] } // SigmaFor returns the sigma node for v coming from pred. func (b *BasicBlock) SigmaFor(v Value, pred *BasicBlock) *Sigma { for _, instr := range b.Instrs { sigma, ok := instr.(*Sigma) if !ok { // no more sigmas return nil } if sigma.From == pred && sigma.X == v { return sigma } } return nil } // Parent returns the function that contains block b. func (b *BasicBlock) Parent() *Function { return b.parent } // String returns a human-readable label of this block. // It is not guaranteed unique within the function. func (b *BasicBlock) String() string { return fmt.Sprintf("%d", b.Index) } // emit appends an instruction to the current basic block. // If the instruction defines a Value, it is returned. func (b *BasicBlock) emit(i Instruction, source ast.Node) Value { i.setSource(source) i.setBlock(b) b.Instrs = append(b.Instrs, i) v, _ := i.(Value) return v } // predIndex returns the i such that b.Preds[i] == c or panics if // there is none. func (b *BasicBlock) predIndex(c *BasicBlock) int { for i, pred := range b.Preds { if pred == c { return i } } panic(fmt.Sprintf("no edge %s -> %s", c, b)) } // succIndex returns the i such that b.Succs[i] == c or -1 if there is none. func (b *BasicBlock) succIndex(c *BasicBlock) int { for i, succ := range b.Succs { if succ == c { return i } } return -1 } // hasPhi returns true if b.Instrs contains φ-nodes. func (b *BasicBlock) hasPhi() bool { _, ok := b.Instrs[0].(*Phi) return ok } func (b *BasicBlock) Phis() []Instruction { return b.phis() } // phis returns the prefix of b.Instrs containing all the block's φ-nodes. func (b *BasicBlock) phis() []Instruction { for i, instr := range b.Instrs { if _, ok := instr.(*Phi); !ok { return b.Instrs[:i] } } return nil // unreachable in well-formed blocks } // replacePred replaces all occurrences of p in b's predecessor list with q. // Ordinarily there should be at most one. func (b *BasicBlock) replacePred(p, q *BasicBlock) { for i, pred := range b.Preds { if pred == p { b.Preds[i] = q } } } // replaceSucc replaces all occurrences of p in b's successor list with q. // Ordinarily there should be at most one. func (b *BasicBlock) replaceSucc(p, q *BasicBlock) { for i, succ := range b.Succs { if succ == p { b.Succs[i] = q } } } // removePred removes all occurrences of p in b's // predecessor list and φ-nodes. // Ordinarily there should be at most one. func (b *BasicBlock) removePred(p *BasicBlock) { phis := b.phis() // We must preserve edge order for φ-nodes. j := 0 for i, pred := range b.Preds { if pred != p { b.Preds[j] = b.Preds[i] // Strike out φ-edge too. for _, instr := range phis { phi := instr.(*Phi) phi.Edges[j] = phi.Edges[i] } j++ } } // Nil out b.Preds[j:] and φ-edges[j:] to aid GC. for i := j; i < len(b.Preds); i++ { b.Preds[i] = nil for _, instr := range phis { instr.(*Phi).Edges[i] = nil } } b.Preds = b.Preds[:j] for _, instr := range phis { phi := instr.(*Phi) phi.Edges = phi.Edges[:j] } } // Destinations associated with unlabelled for/switch/select stmts. // We push/pop one of these as we enter/leave each construct and for // each BranchStmt we scan for the innermost target of the right type. type targets struct { tail *targets // rest of stack _break *BasicBlock _continue *BasicBlock _fallthrough *BasicBlock } // Destinations associated with a labelled block. // We populate these as labels are encountered in forward gotos or // labelled statements. // Forward gotos are resolved once it is known which statement they // are associated with inside the Function. type lblock struct { label *types.Label // Label targeted by the blocks. resolved bool // _goto block encountered (back jump or resolved fwd jump) _goto *BasicBlock _break *BasicBlock _continue *BasicBlock } // label returns the symbol denoted by a label identifier. // // label should be a non-blank identifier (label.Name != "_"). func (f *Function) label(label *ast.Ident) *types.Label { return f.Pkg.objectOf(label).(*types.Label) } // lblockOf returns the branch target associated with the // specified label, creating it if needed. func (f *Function) lblockOf(label *types.Label) *lblock { lb := f.lblocks[label] if lb == nil { lb = &lblock{ label: label, _goto: f.newBasicBlock(label.Name()), } if f.lblocks == nil { f.lblocks = make(map[*types.Label]*lblock) } f.lblocks[label] = lb } return lb } // labelledBlock searches f for the block of the specified label. // // If f is a yield function, it additionally searches ancestor Functions // corresponding to enclosing range-over-func statements within the // same source function, so the returned block may belong to a different Function. func labelledBlock(f *Function, label *types.Label, tok token.Token) *BasicBlock { if lb := f.lblocks[label]; lb != nil { var block *BasicBlock switch tok { case token.BREAK: block = lb._break case token.CONTINUE: block = lb._continue case token.GOTO: block = lb._goto } if block != nil { return block } } // Search ancestors if this is a yield function. if f.jump != nil { return labelledBlock(f.parent, label, tok) } return nil } // targetedBlock looks for the nearest block in f.targets // (and f's ancestors) that matches tok's type, and returns // the block and function it was found in. func targetedBlock(f *Function, tok token.Token) *BasicBlock { if f == nil { return nil } for t := f.targets; t != nil; t = t.tail { var block *BasicBlock switch tok { case token.BREAK: block = t._break case token.CONTINUE: block = t._continue case token.FALLTHROUGH: block = t._fallthrough } if block != nil { return block } } // Search f's ancestors (in case f is a yield function). return targetedBlock(f.parent, tok) } // addResultVar adds a result for a variable v to f.results and v to f.returnVars. func (f *Function) addResultVar(v *types.Var, source ast.Node) { name := v.Name() if name == "" { name = fmt.Sprintf("res.%d", len(f.results)) } result := emitLocalVar(f, v, source) result.comment = name f.results = append(f.results, result) f.returnVars = append(f.returnVars, v) } func (f *Function) addParamVar(v *types.Var, source ast.Node) *Parameter { name := v.Name() if name == "" { name = fmt.Sprintf("arg%d", len(f.Params)) } var b *BasicBlock if len(f.Blocks) > 0 { b = f.Blocks[0] } param := &Parameter{name: name} param.setBlock(b) param.setType(v.Type()) param.setSource(source) param.object = v f.Params = append(f.Params, param) if b != nil { f.Blocks[0].Instrs = append(f.Blocks[0].Instrs, param) } return param } // addSpilledParam declares a parameter that is pre-spilled to the // stack; the function body will load/store the spilled location. // Subsequent lifting will eliminate spills where possible. func (f *Function) addSpilledParam(obj *types.Var, source ast.Node) { param := f.addParamVar(obj, source) spill := emitLocalVar(f, obj, source) emitStore(f, spill, param, source) // f.emit(&Store{Addr: spill, Val: param}) } // startBody initializes the function prior to generating IR code for its body. // Precondition: f.Type() already set. func (f *Function) startBody() { entry := f.newBasicBlock("entry") f.currentBlock = entry f.vars = make(map[*types.Var]Value) // needed for some synthetics, e.g. init } func (f *Function) blockset(i int) *BlockSet { bs := &f.blocksets[i] if len(bs.values) != len(f.Blocks) { if cap(bs.values) >= len(f.Blocks) { bs.values = bs.values[:len(f.Blocks)] bs.Clear() } else { bs.values = make([]bool, len(f.Blocks)) } } else { bs.Clear() } return bs } func (f *Function) exitBlock() { old := f.currentBlock f.Exit = f.newBasicBlock("exit") f.currentBlock = f.Exit results := make([]Value, len(f.results)) // Run function calls deferred in this // function when explicitly returning from it. f.emit(new(RunDefers), nil) for i, r := range f.results { results[i] = emitLoad(f, r, nil) } f.emit(&Return{Results: results}, nil) f.currentBlock = old } // createSyntacticParams populates f.Params and generates code (spills // and named result locals) for all the parameters declared in the // syntax. In addition it populates the f.objects mapping. // // Preconditions: // f.startBody() was called. // Postcondition: // len(f.Params) == len(f.Signature.Params) + (f.Signature.Recv() ? 1 : 0) func (f *Function) createSyntacticParams(recv *ast.FieldList, functype *ast.FuncType) { // Receiver (at most one inner iteration). if recv != nil { for _, field := range recv.List { for _, n := range field.Names { f.addSpilledParam(identVar(f, n), n) } // Anonymous receiver? No need to spill. if field.Names == nil { f.addParamVar(f.Signature.Recv(), field) } } } // Parameters. if functype.Params != nil { n := len(f.Params) // 1 if has recv, 0 otherwise for _, field := range functype.Params.List { for _, n := range field.Names { f.addSpilledParam(identVar(f, n), n) } // Anonymous parameter? No need to spill. if field.Names == nil { f.addParamVar(f.Signature.Params().At(len(f.Params)-n), field) } } } // Results. if functype.Results != nil { for _, field := range functype.Results.List { // Implicit "var" decl of locals for named results. for _, n := range field.Names { v := identVar(f, n) f.addResultVar(v, n) } // Implicit "var" decl of local for an unnamed result. if field.Names == nil { v := f.Signature.Results().At(len(f.results)) f.addResultVar(v, field.Type) } } } } // createDeferStack initializes fn.deferstack to a local variable // initialized to a ssa:deferstack() call. func (fn *Function) createDeferStack() { // Each syntactic function makes a call to ssa:deferstack, // which is spilled to a local. Unused ones are later removed. fn.deferstack = newVar("defer$stack", tDeferStack) call := &Call{Call: CallCommon{Value: vDeferStack}} call.setType(tDeferStack) deferstack := fn.emit(call, nil) spill := emitLocalVar(fn, fn.deferstack, nil) emitStore(fn, spill, deferstack, nil) } func numberNodes(f *Function) { var base ID for _, b := range f.Blocks { for _, instr := range b.Instrs { if instr == nil { continue } base++ instr.setID(base) } } } func updateOperandsReferrers(instr Instruction, ops []*Value) { for _, op := range ops { if r := *op; r != nil { if refs := (*op).Referrers(); refs != nil { if len(*refs) == 0 { // per median, each value has two referrers, so we can avoid one call into growslice // // Note: we experimented with allocating // sequential scratch space, but we // couldn't find a value that gave better // performance than making many individual // allocations *refs = make([]Instruction, 1, 2) (*refs)[0] = instr } else { *refs = append(*refs, instr) } } } } } // buildReferrers populates the def/use information in all non-nil // Value.Referrers slice. // Precondition: all such slices are initially empty. func buildReferrers(f *Function) { var rands []*Value for _, b := range f.Blocks { for _, instr := range b.Instrs { rands = instr.Operands(rands[:0]) // recycle storage updateOperandsReferrers(instr, rands) } } for _, c := range f.consts { rands = c.c.Operands(rands[:0]) updateOperandsReferrers(c.c, rands) } } func (f *Function) emitConsts() { defer func() { f.consts = nil f.aggregateConsts = typeutil.Map[[]*AggregateConst]{} }() if len(f.Blocks) == 0 { return } // TODO(dh): our deduplication only works on booleans and // integers. other constants are represented as pointers to // things. head := make([]constValue, 0, len(f.consts)) for _, c := range f.consts { if len(*c.c.Referrers()) == 0 { // TODO(dh): killing a const may make other consts dead, too killInstruction(c.c) } else { head = append(head, c) } } sort.Slice(head, func(i, j int) bool { return head[i].idx < head[j].idx }) entry := f.Blocks[0] instrs := make([]Instruction, 0, len(entry.Instrs)+len(head)) for _, c := range head { instrs = append(instrs, c.c) } f.aggregateConsts.Iterate(func(key types.Type, value []*AggregateConst) { for _, c := range value { instrs = append(instrs, c) } }) instrs = append(instrs, entry.Instrs...) entry.Instrs = instrs } // buildFakeExits ensures that every block in the function is // reachable in reverse from the Exit block. This is required to build // a full post-dominator tree, and to ensure the exit block's // inclusion in the dominator tree. func buildFakeExits(fn *Function) { // Find back-edges via forward DFS fn.fakeExits = BlockSet{values: make([]bool, len(fn.Blocks))} seen := fn.blockset(0) backEdges := fn.blockset(1) var dfs func(b *BasicBlock) dfs = func(b *BasicBlock) { if !seen.Add(b) { backEdges.Add(b) return } for _, pred := range b.Succs { dfs(pred) } } dfs(fn.Blocks[0]) buildLoop: for { seen := fn.blockset(2) var dfs func(b *BasicBlock) dfs = func(b *BasicBlock) { if !seen.Add(b) { return } for _, pred := range b.Preds { dfs(pred) } if b == fn.Exit { for _, b := range fn.Blocks { if fn.fakeExits.Has(b) { dfs(b) } } } } dfs(fn.Exit) for _, b := range fn.Blocks { if !seen.Has(b) && backEdges.Has(b) { // Block b is not reachable from the exit block. Add a // fake jump from b to exit, then try again. Note that we // only add one fake edge at a time, as it may make // multiple blocks reachable. // // We only consider those blocks that have back edges. // Any unreachable block that doesn't have a back edge // must flow into a loop, which by definition has a // back edge. Thus, by looking for loops, we should // need fewer fake edges overall. fn.fakeExits.Add(b) continue buildLoop } } break } } // finishBody() finalizes the function after IR code generation of its body. func (f *Function) finishBody() { f.currentBlock = nil f.lblocks = nil // Remove from f.Locals any Allocs that escape to the heap. j := 0 for _, l := range f.Locals { if !l.Heap { f.Locals[j] = l j++ } } // Nil out f.Locals[j:] to aid GC. for i := j; i < len(f.Locals); i++ { f.Locals[i] = nil } f.Locals = f.Locals[:j] optimizeBlocks(f) buildFakeExits(f) buildReferrers(f) buildDomTree(f) buildPostDomTree(f) if f.Prog.mode&NaiveForm == 0 { for lift(f) { } if doSimplifyConstantCompositeValues { for simplifyConstantCompositeValues(f) { } } } // emit constants after lifting, because lifting may produce new constants, but before other variable splitting, // because it expects constants to have been deduplicated. f.emitConsts() if f.Prog.mode&SplitAfterNewInformation != 0 { splitOnNewInformation(f.Blocks[0], &StackMap{}) } // clear remaining builder state f.results = nil // (used by lifting) f.deferstack = nil // (used by lifting) f.vars = nil // (used by lifting) f.goversion = "" numberNodes(f) defer f.wr.Close() f.wr.WriteFunc("start", "start", f) if f.Prog.mode&PrintFunctions != 0 { printMu.Lock() f.WriteTo(os.Stdout) printMu.Unlock() } if f.Prog.mode&SanityCheckFunctions != 0 { mustSanityCheck(f, nil) } } func isUselessPhi(phi *Phi) (Value, bool) { var v0 Value for _, e := range phi.Edges { if e == phi { continue } if v0 == nil { v0 = e } if v0 != e { if v0, ok := v0.(*Const); ok { if e, ok := e.(*Const); ok { if v0.typ == e.typ && v0.Value == e.Value { continue } } } return nil, false } } return v0, true } func (f *Function) RemoveNilBlocks() { f.removeNilBlocks() } // removeNilBlocks eliminates nils from f.Blocks and updates each // BasicBlock.Index. Use this after any pass that may delete blocks. func (f *Function) removeNilBlocks() { j := 0 for _, b := range f.Blocks { if b != nil { b.Index = j f.Blocks[j] = b j++ } } // Nil out f.Blocks[j:] to aid GC. for i := j; i < len(f.Blocks); i++ { f.Blocks[i] = nil } f.Blocks = f.Blocks[:j] } // SetDebugMode sets the debug mode for package pkg. If true, all its // functions will include full debug info. This greatly increases the // size of the instruction stream, and causes Functions to depend upon // the ASTs, potentially keeping them live in memory for longer. func (pkg *Package) SetDebugMode(debug bool) { // TODO(adonovan): do we want ast.File granularity? pkg.debug = debug } // debugInfo reports whether debug info is wanted for this function. func (f *Function) debugInfo() bool { return f.Pkg != nil && f.Pkg.debug } // lookup returns the address of the named variable identified by obj // that is local to function f or one of its enclosing functions. // If escaping, the reference comes from a potentially escaping pointer // expression and the referent must be heap-allocated. // We assume the referent is a *Alloc or *Phi. // (The only Phis at this stage are those created directly by go1.22 "for" loops.) func (f *Function) lookup(obj *types.Var, escaping bool) Value { if v, ok := f.vars[obj]; ok { if escaping { switch v := v.(type) { case *Alloc: v.Heap = true case *Phi: for _, edge := range v.Edges { if alloc, ok := edge.(*Alloc); ok { alloc.Heap = true } } } } return v // function-local var (address) } // Definition must be in an enclosing function; // plumb it through intervening closures. if f.parent == nil { panic("no ir.Value for " + obj.String()) } outer := f.parent.lookup(obj, true) // escaping v := &FreeVar{ name: obj.Name(), typ: outer.Type(), outer: outer, parent: f, } f.vars[obj] = v f.FreeVars = append(f.FreeVars, v) return v } // emit emits the specified instruction to function f. func (f *Function) emit(instr Instruction, source ast.Node) Value { return f.currentBlock.emit(instr, source) } // RelString returns the full name of this function, qualified by // package name, receiver type, etc. // // The specific formatting rules are not guaranteed and may change. // // Examples: // // "math.IsNaN" // a package-level function // "(*bytes.Buffer).Bytes" // a declared method or a wrapper // "(*bytes.Buffer).Bytes$thunk" // thunk (func wrapping method; receiver is param 0) // "(*bytes.Buffer).Bytes$bound" // bound (func wrapping method; receiver supplied by closure) // "main.main$1" // an anonymous function in main // "main.init#1" // a declared init function // "main.init" // the synthesized package initializer // // When these functions are referred to from within the same package // (i.e. from == f.Pkg.Object), they are rendered without the package path. // For example: "IsNaN", "(*Buffer).Bytes", etc. // // All non-synthetic functions have distinct package-qualified names. // (But two methods may have the same name "(T).f" if one is a synthetic // wrapper promoting a non-exported method "f" from another package; in // that case, the strings are equal but the identifiers "f" are distinct.) func (f *Function) RelString(from *types.Package) string { // Anonymous? if f.parent != nil { // An anonymous function's Name() looks like "parentName$1", // but its String() should include the type/package/etc. parent := f.parent.RelString(from) for i, anon := range f.parent.AnonFuncs { if anon == f { return fmt.Sprintf("%s$%d", parent, 1+i) } } return f.name // should never happen } // Method (declared or wrapper)? if recv := f.Signature.Recv(); recv != nil { return f.relMethod(from, recv.Type()) } // Thunk? if f.method != nil { return f.relMethod(from, f.method.Recv()) } // Bound? if len(f.FreeVars) == 1 && strings.HasSuffix(f.name, "$bound") { return f.relMethod(from, f.FreeVars[0].Type()) } // Package-level function? // Prefix with package name for cross-package references only. if p := f.pkg(); p != nil && p != from { return fmt.Sprintf("%s.%s", p.Path(), f.name) } // Unknown. return f.name } func (f *Function) relMethod(from *types.Package, recv types.Type) string { return fmt.Sprintf("(%s).%s", relType(recv, from), f.name) } // writeSignature writes to buf the signature sig in declaration syntax. func writeSignature(buf *bytes.Buffer, from *types.Package, name string, sig *types.Signature) { buf.WriteString("func ") if recv := sig.Recv(); recv != nil { buf.WriteString("(") if name := recv.Name(); name != "" { buf.WriteString(name) buf.WriteString(" ") } types.WriteType(buf, recv.Type(), types.RelativeTo(from)) buf.WriteString(") ") } buf.WriteString(name) types.WriteSignature(buf, sig, types.RelativeTo(from)) } func (f *Function) pkg() *types.Package { if f.Pkg != nil { return f.Pkg.Pkg } return nil } var _ io.WriterTo = (*Function)(nil) // *Function implements io.Writer func (f *Function) WriteTo(w io.Writer) (int64, error) { var buf bytes.Buffer WriteFunction(&buf, f) n, err := w.Write(buf.Bytes()) return int64(n), err } // WriteFunction writes to buf a human-readable "disassembly" of f. func WriteFunction(buf *bytes.Buffer, f *Function) { fmt.Fprintf(buf, "# Name: %s\n", f.String()) if f.Pkg != nil { fmt.Fprintf(buf, "# Package: %s\n", f.Pkg.Pkg.Path()) } if syn := f.Synthetic; syn != 0 { fmt.Fprintln(buf, "# Synthetic:", syn) } if pos := f.Pos(); pos.IsValid() { fmt.Fprintf(buf, "# Location: %s\n", f.Prog.Fset.Position(pos)) } if f.parent != nil { fmt.Fprintf(buf, "# Parent: %s\n", f.parent.Name()) } from := f.pkg() if f.FreeVars != nil { buf.WriteString("# Free variables:\n") for i, fv := range f.FreeVars { fmt.Fprintf(buf, "# % 3d:\t%s %s\n", i, fv.Name(), relType(fv.Type(), from)) } } if len(f.Locals) > 0 { buf.WriteString("# Locals:\n") for i, l := range f.Locals { fmt.Fprintf(buf, "# % 3d:\t%s %s\n", i, l.Name(), relType(deref(l.Type()), from)) } } writeSignature(buf, from, f.Name(), f.Signature) buf.WriteString(":\n") if f.Blocks == nil { buf.WriteString("\t(external)\n") } for _, b := range f.Blocks { if b == nil { // Corrupt CFG. fmt.Fprintf(buf, ".nil:\n") continue } fmt.Fprintf(buf, "b%d:", b.Index) if len(b.Preds) > 0 { fmt.Fprint(buf, " ←") for _, pred := range b.Preds { fmt.Fprintf(buf, " b%d", pred.Index) } } if b.Comment != "" { fmt.Fprintf(buf, " # %s", b.Comment) } buf.WriteByte('\n') if false { // CFG debugging fmt.Fprintf(buf, "\t# CFG: %s --> %s --> %s\n", b.Preds, b, b.Succs) } buf2 := &bytes.Buffer{} for _, instr := range b.Instrs { buf.WriteString("\t") switch v := instr.(type) { case Value: // Left-align the instruction. if name := v.Name(); name != "" { fmt.Fprintf(buf, "%s = ", name) } buf.WriteString(instr.String()) case nil: // Be robust against bad transforms. buf.WriteString("") default: buf.WriteString(instr.String()) } if instr != nil && instr.Comment() != "" { buf.WriteString(" # ") buf.WriteString(instr.Comment()) } buf.WriteString("\n") if f.Prog.mode&PrintSource != 0 { if s := instr.Source(); s != nil { buf2.Reset() format.Node(buf2, f.Prog.Fset, s) for { line, err := buf2.ReadString('\n') if len(line) == 0 { break } buf.WriteString("\t\t> ") buf.WriteString(line) if line[len(line)-1] != '\n' { buf.WriteString("\n") } if err != nil { break } } } } } buf.WriteString("\n") } } // newBasicBlock adds to f a new basic block and returns it. It does // not automatically become the current block for subsequent calls to emit. // comment is an optional string for more readable debugging output. func (f *Function) newBasicBlock(comment string) *BasicBlock { var instrs []Instruction if len(f.functionBody.scratchInstructions) > 0 { instrs = f.functionBody.scratchInstructions[0:0:avgInstructionsPerBlock] f.functionBody.scratchInstructions = f.functionBody.scratchInstructions[avgInstructionsPerBlock:] } else { instrs = make([]Instruction, 0, avgInstructionsPerBlock) } b := &BasicBlock{ Index: len(f.Blocks), Comment: comment, parent: f, Instrs: instrs, } b.Succs = b.succs2[:0] f.Blocks = append(f.Blocks, b) return b } // NewFunction returns a new synthetic Function instance belonging to // prog, with its name and signature fields set as specified. // // The caller is responsible for initializing the remaining fields of // the function object, e.g. Pkg, Params, Blocks. // // It is practically impossible for clients to construct well-formed // IR functions/packages/programs directly, so we assume this is the // job of the Builder alone. NewFunction exists to provide clients a // little flexibility. For example, analysis tools may wish to // construct fake Functions for the root of the callgraph, a fake // "reflect" package, etc. // // TODO(adonovan): think harder about the API here. func (prog *Program) NewFunction(name string, sig *types.Signature, provenance Synthetic) *Function { return &Function{Prog: prog, name: name, Signature: sig, Synthetic: provenance} } //lint:ignore U1000 we may make use of this for functions loaded from export data type extentNode [2]token.Pos func (n extentNode) Pos() token.Pos { return n[0] } func (n extentNode) End() token.Pos { return n[1] } func (f *Function) initHTML(name string) { if name == "" { return } if rel := f.RelString(nil); rel == name { f.wr = NewHTMLWriter("ir.html", rel, "") } } func killInstruction(instr Instruction) { ops := instr.Operands(nil) for _, op := range ops { if refs := (*op).Referrers(); refs != nil { *refs = removeInstr(*refs, instr) } } } // identVar returns the variable defined by id. func identVar(fn *Function, id *ast.Ident) *types.Var { return fn.Pkg.info.Defs[id].(*types.Var) } // unique returns a unique positive int within the source tree of f. // The source tree of f includes all of f's ancestors by parent and all // of the AnonFuncs contained within these. func unique(f *Function) int64 { f.uniq++ return f.uniq } // exit is a change of control flow going from a range-over-func // yield function to an ancestor function caused by a break, continue, // goto, or return statement. // // There are 3 types of exits: // * return from the source function (from ReturnStmt), // * jump to a block (from break and continue statements [labelled/unlabelled]), // * go to a label (from goto statements). // // As the builder does one pass over the ast, it is unclear whether // a forward goto statement will leave a range-over-func body. // The function being exited to is unresolved until the end // of building the range-over-func body. type exit struct { id int64 // unique value for exit within from and to from *Function // the function the exit starts from to *Function // the function being exited to (nil if unresolved) source ast.Node block *BasicBlock // basic block within to being jumped to. label *types.Label // forward label being jumped to via goto. // block == nil && label == nil => return } // storeVar emits to function f code to store a value v to a *types.Var x. func storeVar(f *Function, x *types.Var, v Value, source ast.Node) { emitStore(f, f.lookup(x, true), v, source) } // labelExit creates a new exit to a yield fn to exit the function using a label. func labelExit(fn *Function, label *types.Label, source ast.Node) *exit { e := &exit{ id: unique(fn), from: fn, to: nil, source: source, label: label, } fn.exits = append(fn.exits, e) return e } // blockExit creates a new exit to a yield fn that jumps to a basic block. func blockExit(fn *Function, block *BasicBlock, source ast.Node) *exit { e := &exit{ id: unique(fn), from: fn, to: block.parent, source: source, block: block, } fn.exits = append(fn.exits, e) return e } // returnExit creates a new exit to a yield fn that returns to the source function. func returnExit(fn *Function, source ast.Node) *exit { e := &exit{ id: unique(fn), from: fn, to: fn.sourceFn, source: source, } fn.exits = append(fn.exits, e) return e } golang-honnef-go-tools-2024.1/go/ir/html.go000066400000000000000000000672161465704072200204220ustar00rootroot00000000000000// Copyright 2015 The Go Authors. All rights reserved. // Copyright 2019 Dominik Honnef. All rights reserved. package ir import ( "bytes" "fmt" "go/types" "html" "io" "log" "os" "os/exec" "path/filepath" "reflect" "sort" "strings" ) func live(f *Function) []bool { max := 0 var ops []*Value for _, b := range f.Blocks { for _, instr := range b.Instrs { if int(instr.ID()) > max { max = int(instr.ID()) } } } out := make([]bool, max+1) var q []Node for _, b := range f.Blocks { for _, instr := range b.Instrs { switch instr.(type) { case *BlankStore, *Call, *ConstantSwitch, *Defer, *Go, *If, *Jump, *MapUpdate, *Next, *Panic, *Recv, *Return, *RunDefers, *Send, *Store, *Unreachable: out[instr.ID()] = true q = append(q, instr) } } } for len(q) > 0 { v := q[len(q)-1] q = q[:len(q)-1] for _, op := range v.Operands(ops) { if *op == nil { continue } if !out[(*op).ID()] { out[(*op).ID()] = true q = append(q, *op) } } } return out } type funcPrinter interface { startBlock(b *BasicBlock, reachable bool) endBlock(b *BasicBlock) value(v Node, live bool) startDepCycle() endDepCycle() named(n string, vals []Value) } func namedValues(f *Function) map[types.Object][]Value { names := map[types.Object][]Value{} for _, b := range f.Blocks { for _, instr := range b.Instrs { if instr, ok := instr.(*DebugRef); ok { if obj := instr.object; obj != nil { names[obj] = append(names[obj], instr.X) } } } } // XXX deduplicate values return names } func fprintFunc(p funcPrinter, f *Function) { // XXX does our IR form preserve unreachable blocks? // reachable, live := findlive(f) l := live(f) for _, b := range f.Blocks { // XXX // p.startBlock(b, reachable[b.Index]) p.startBlock(b, true) end := len(b.Instrs) - 1 if end < 0 { end = 0 } for _, v := range b.Instrs[:end] { if _, ok := v.(*DebugRef); !ok { p.value(v, l[v.ID()]) } } p.endBlock(b) } names := namedValues(f) keys := make([]types.Object, 0, len(names)) for key := range names { keys = append(keys, key) } sort.Slice(keys, func(i, j int) bool { return keys[i].Pos() < keys[j].Pos() }) for _, key := range keys { p.named(key.Name(), names[key]) } } func opName(v Node) string { switch v := v.(type) { case *Call: if v.Common().IsInvoke() { return "Invoke" } return "Call" case *Alloc: if v.Heap { return "HeapAlloc" } return "StackAlloc" case *Select: if v.Blocking { return "SelectBlocking" } return "SelectNonBlocking" default: return reflect.ValueOf(v).Type().Elem().Name() } } type HTMLWriter struct { w io.WriteCloser path string dot *dotWriter } func NewHTMLWriter(path string, funcname, cfgMask string) *HTMLWriter { out, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644) if err != nil { log.Fatalf("%v", err) } pwd, err := os.Getwd() if err != nil { log.Fatalf("%v", err) } html := HTMLWriter{w: out, path: filepath.Join(pwd, path)} html.dot = newDotWriter() html.start(funcname) return &html } func (w *HTMLWriter) start(name string) { if w == nil { return } w.WriteString("") w.WriteString(` `) w.WriteString("") w.WriteString("

") w.WriteString(html.EscapeString(name)) w.WriteString("

") w.WriteString(` help

Click on a value or block to toggle highlighting of that value/block and its uses. (Values and blocks are highlighted by ID, and IDs of dead items may be reused, so not all highlights necessarily correspond to the clicked item.)

Faded out values and blocks are dead code that has not been eliminated.

Values printed in italics have a dependency cycle.

CFG: Dashed edge is for unlikely branches. Blue color is for backward edges. Edge with a dot means that this edge follows the order in which blocks were laid out.

`) w.WriteString("") w.WriteString("") } func (w *HTMLWriter) Close() { if w == nil { return } io.WriteString(w.w, "") io.WriteString(w.w, "
") io.WriteString(w.w, "") io.WriteString(w.w, "") w.w.Close() fmt.Printf("dumped IR to %v\n", w.path) } // WriteFunc writes f in a column headed by title. // phase is used for collapsing columns and should be unique across the table. func (w *HTMLWriter) WriteFunc(phase, title string, f *Function) { if w == nil { return } w.WriteColumn(phase, title, "", funcHTML(f, phase, w.dot)) } // WriteColumn writes raw HTML in a column headed by title. // It is intended for pre- and post-compilation log output. func (w *HTMLWriter) WriteColumn(phase, title, class, html string) { if w == nil { return } id := strings.Replace(phase, " ", "-", -1) // collapsed column w.Printf("
%v
", id, phase) if class == "" { w.Printf("", id) } else { w.Printf("", id, class) } w.WriteString("

" + title + "

") w.WriteString(html) w.WriteString("") } func (w *HTMLWriter) Printf(msg string, v ...interface{}) { if _, err := fmt.Fprintf(w.w, msg, v...); err != nil { log.Fatalf("%v", err) } } func (w *HTMLWriter) WriteString(s string) { if _, err := io.WriteString(w.w, s); err != nil { log.Fatalf("%v", err) } } func valueHTML(v Node) string { if v == nil { return "<nil>" } // TODO: Using the value ID as the class ignores the fact // that value IDs get recycled and that some values // are transmuted into other values. class := fmt.Sprintf("t%d", v.ID()) var label string switch v := v.(type) { case *Function: label = v.RelString(nil) case *Builtin: label = v.Name() default: label = class } return fmt.Sprintf("%s", class, label) } func valueLongHTML(v Node) string { // TODO: Any intra-value formatting? // I'm wary of adding too much visual noise, // but a little bit might be valuable. // We already have visual noise in the form of punctuation // maybe we could replace some of that with formatting. s := fmt.Sprintf("", v.ID()) linenumber := "(?)" if v.Pos().IsValid() { line := v.Parent().Prog.Fset.Position(v.Pos()).Line linenumber = fmt.Sprintf("(%d)", line, line) } s += fmt.Sprintf("%s %s = %s", valueHTML(v), linenumber, opName(v)) if v, ok := v.(Value); ok { s += " <" + html.EscapeString(v.Type().String()) + ">" } switch v := v.(type) { case *Parameter: s += fmt.Sprintf(" {%s}", html.EscapeString(v.name)) case *BinOp: s += fmt.Sprintf(" {%s}", html.EscapeString(v.Op.String())) case *UnOp: s += fmt.Sprintf(" {%s}", html.EscapeString(v.Op.String())) case *Extract: name := v.Tuple.Type().(*types.Tuple).At(v.Index).Name() s += fmt.Sprintf(" [%d] (%s)", v.Index, name) case *Field: st := v.X.Type().Underlying().(*types.Struct) // Be robust against a bad index. name := "?" if 0 <= v.Field && v.Field < st.NumFields() { name = st.Field(v.Field).Name() } s += fmt.Sprintf(" [%d] (%s)", v.Field, name) case *FieldAddr: st := deref(v.X.Type()).Underlying().(*types.Struct) // Be robust against a bad index. name := "?" if 0 <= v.Field && v.Field < st.NumFields() { name = st.Field(v.Field).Name() } s += fmt.Sprintf(" [%d] (%s)", v.Field, name) case *Recv: s += fmt.Sprintf(" {%t}", v.CommaOk) case *Call: if v.Common().IsInvoke() { s += fmt.Sprintf(" {%s}", html.EscapeString(v.Common().Method.FullName())) } case *Const: if v.Value == nil { s += " {<nil>}" } else { s += fmt.Sprintf(" {%s}", html.EscapeString(v.Value.String())) } case *Sigma: s += fmt.Sprintf(" [#%s]", v.From) } for _, a := range v.Operands(nil) { s += fmt.Sprintf(" %s", valueHTML(*a)) } if v, ok := v.(Instruction); ok { s += fmt.Sprintf(" (%s)", v.Comment()) } // OPT(dh): we're calling namedValues many times on the same function. allNames := namedValues(v.Parent()) var names []string for name, values := range allNames { for _, value := range values { if v == value { names = append(names, name.Name()) break } } } if len(names) != 0 { s += " (" + strings.Join(names, ", ") + ")" } s += "" return s } func blockHTML(b *BasicBlock) string { // TODO: Using the value ID as the class ignores the fact // that value IDs get recycled and that some values // are transmuted into other values. s := html.EscapeString(b.String()) return fmt.Sprintf("%s", s, s) } func blockLongHTML(b *BasicBlock) string { var kind string var term Instruction if len(b.Instrs) > 0 { term = b.Control() kind = opName(term) } // TODO: improve this for HTML? s := fmt.Sprintf("%s", b.Index, kind) if term != nil { ops := term.Operands(nil) if len(ops) > 0 { var ss []string for _, op := range ops { ss = append(ss, valueHTML(*op)) } s += " " + strings.Join(ss, ", ") } } if len(b.Succs) > 0 { s += " →" // right arrow for _, c := range b.Succs { s += " " + blockHTML(c) } } return s } func funcHTML(f *Function, phase string, dot *dotWriter) string { buf := new(bytes.Buffer) if dot != nil { dot.writeFuncSVG(buf, phase, f) } fmt.Fprint(buf, "") p := htmlFuncPrinter{w: buf} fprintFunc(p, f) // fprintFunc(&buf, f) // TODO: HTML, not text,
for line breaks, etc. fmt.Fprint(buf, "") return buf.String() } type htmlFuncPrinter struct { w io.Writer } func (p htmlFuncPrinter) startBlock(b *BasicBlock, reachable bool) { var dead string if !reachable { dead = "dead-block" } fmt.Fprintf(p.w, "
    ", b, dead) fmt.Fprintf(p.w, "
  • %s:", blockHTML(b)) if len(b.Preds) > 0 { io.WriteString(p.w, " ←") // left arrow for _, pred := range b.Preds { fmt.Fprintf(p.w, " %s", blockHTML(pred)) } } if len(b.Instrs) > 0 { io.WriteString(p.w, ``) } io.WriteString(p.w, "
    • ") if len(b.Instrs) > 0 { // start list of values io.WriteString(p.w, "
  • ") io.WriteString(p.w, "
      ") } } func (p htmlFuncPrinter) endBlock(b *BasicBlock) { if len(b.Instrs) > 0 { // end list of values io.WriteString(p.w, "
    ") io.WriteString(p.w, "
    • ") } io.WriteString(p.w, "
  • ") fmt.Fprint(p.w, blockLongHTML(b)) io.WriteString(p.w, "
    • ") io.WriteString(p.w, "
") } func (p htmlFuncPrinter) value(v Node, live bool) { var dead string if !live { dead = "dead-value" } fmt.Fprintf(p.w, "
  • ", dead) fmt.Fprint(p.w, valueLongHTML(v)) io.WriteString(p.w, "
    • ") } func (p htmlFuncPrinter) startDepCycle() { fmt.Fprintln(p.w, "") } func (p htmlFuncPrinter) endDepCycle() { fmt.Fprintln(p.w, "") } func (p htmlFuncPrinter) named(n string, vals []Value) { fmt.Fprintf(p.w, "
  • name %s: ", n) for _, val := range vals { fmt.Fprintf(p.w, "%s ", valueHTML(val)) } fmt.Fprintf(p.w, "
    • ") } type dotWriter struct { path string broken bool } // newDotWriter returns non-nil value when mask is valid. // dotWriter will generate SVGs only for the phases specified in the mask. // mask can contain following patterns and combinations of them: // * - all of them; // x-y - x through y, inclusive; // x,y - x and y, but not the passes between. func newDotWriter() *dotWriter { path, err := exec.LookPath("dot") if err != nil { fmt.Println(err) return nil } return &dotWriter{path: path} } func (d *dotWriter) writeFuncSVG(w io.Writer, phase string, f *Function) { if d.broken { return } cmd := exec.Command(d.path, "-Tsvg") pipe, err := cmd.StdinPipe() if err != nil { d.broken = true fmt.Println(err) return } buf := new(bytes.Buffer) cmd.Stdout = buf bufErr := new(bytes.Buffer) cmd.Stderr = bufErr err = cmd.Start() if err != nil { d.broken = true fmt.Println(err) return } fmt.Fprint(pipe, `digraph "" { margin=0; size="4,40"; ranksep=.2; `) id := strings.Replace(phase, " ", "-", -1) fmt.Fprintf(pipe, `id="g_graph_%s";`, id) fmt.Fprintf(pipe, `node [style=filled,fillcolor=white,fontsize=16,fontname="Menlo,Times,serif",margin="0.01,0.03"];`) fmt.Fprintf(pipe, `edge [fontsize=16,fontname="Menlo,Times,serif"];`) for _, b := range f.Blocks { layout := "" fmt.Fprintf(pipe, `%v [label="%v%s\n%v",id="graph_node_%v_%v"];`, b, b, layout, b.Control().String(), id, b) } indexOf := make([]int, len(f.Blocks)) for i, b := range f.Blocks { indexOf[b.Index] = i } // XXX /* ponums := make([]int32, len(f.Blocks)) _ = postorderWithNumbering(f, ponums) isBackEdge := func(from, to int) bool { return ponums[from] <= ponums[to] } */ isBackEdge := func(from, to int) bool { return false } for _, b := range f.Blocks { for i, s := range b.Succs { style := "solid" color := "black" arrow := "vee" if isBackEdge(b.Index, s.Index) { color = "blue" } fmt.Fprintf(pipe, `%v -> %v [label=" %d ",style="%s",color="%s",arrowhead="%s"];`, b, s, i, style, color, arrow) } } fmt.Fprint(pipe, "}") pipe.Close() err = cmd.Wait() if err != nil { d.broken = true fmt.Printf("dot: %v\n%v\n", err, bufErr.String()) return } svgID := "svg_graph_" + id fmt.Fprintf(w, `
    `, svgID, svgID) // For now, an awful hack: edit the html as it passes through // our fingers, finding ' 0 { fset = initial[0].Fset } prog := ir.NewProgram(fset, mode) if opts != nil { prog.PrintFunc = opts.PrintFunc } isInitial := make(map[*packages.Package]bool, len(initial)) for _, p := range initial { isInitial[p] = true } irmap := make(map[*packages.Package]*ir.Package) packages.Visit(initial, nil, func(p *packages.Package) { if p.Types != nil && !p.IllTyped { var files []*ast.File if deps || isInitial[p] { files = p.Syntax } irmap[p] = prog.CreatePackage(p.Types, files, p.TypesInfo, true) } }) var irpkgs []*ir.Package for _, p := range initial { irpkgs = append(irpkgs, irmap[p]) // may be nil } return prog, irpkgs } // CreateProgram returns a new program in IR form, given a program // loaded from source. An IR package is created for each transitively // error-free package of lprog. // // Code for bodies of functions is not built until Build is called // on the result. // // The mode parameter controls diagnostics and checking during IR construction. // // Deprecated: use golang.org/x/tools/go/packages and the Packages // function instead; see ir.ExampleLoadPackages. func CreateProgram(lprog *loader.Program, mode ir.BuilderMode) *ir.Program { prog := ir.NewProgram(lprog.Fset, mode) for _, info := range lprog.AllPackages { if info.TransitivelyErrorFree { prog.CreatePackage(info.Pkg, info.Files, &info.Info, info.Importable) } } return prog } // BuildPackage builds an IR program with IR for a single package. // // It populates pkg by type-checking the specified file ASTs. All // dependencies are loaded using the importer specified by tc, which // typically loads compiler export data; IR code cannot be built for // those packages. BuildPackage then constructs an ir.Program with all // dependency packages created, and builds and returns the IR package // corresponding to pkg. // // The caller must have set pkg.Path() to the import path. // // The operation fails if there were any type-checking or import errors. // // See ../ir/example_test.go for an example. func BuildPackage(tc *types.Config, fset *token.FileSet, pkg *types.Package, files []*ast.File, mode ir.BuilderMode) (*ir.Package, *types.Info, error) { if fset == nil { panic("no token.FileSet") } if pkg.Path() == "" { panic("package has no import path") } info := &types.Info{ Types: make(map[ast.Expr]types.TypeAndValue), Defs: make(map[*ast.Ident]types.Object), Uses: make(map[*ast.Ident]types.Object), Implicits: make(map[ast.Node]types.Object), Scopes: make(map[ast.Node]*types.Scope), Selections: make(map[*ast.SelectorExpr]*types.Selection), Instances: make(map[*ast.Ident]types.Instance), FileVersions: make(map[*ast.File]string), } if err := types.NewChecker(tc, fset, pkg, info).Files(files); err != nil { return nil, nil, err } prog := ir.NewProgram(fset, mode) // Create IR packages for all imports. // Order is not significant. created := make(map[*types.Package]bool) var createAll func(pkgs []*types.Package) createAll = func(pkgs []*types.Package) { for _, p := range pkgs { if !created[p] { created[p] = true prog.CreatePackage(p, nil, nil, true) createAll(p.Imports()) } } } createAll(pkg.Imports()) // Create and build the primary package. irpkg := prog.CreatePackage(pkg, files, info, false) irpkg.Build() return irpkg, info, nil } ������������������������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/irutil/load_test.go���������������������������������������������0000664�0000000�0000000�00000006720�14657040722�0022735�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// 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. package irutil_test import ( "bytes" "go/ast" "go/importer" "go/parser" "go/token" "go/types" "os" "strings" "testing" "honnef.co/go/tools/go/ir/irutil" "golang.org/x/tools/go/packages" ) const hello = `package main import "fmt" func main() { fmt.Println("Hello, world") } ` func TestBuildPackage(t *testing.T) { // There is a more substantial test of BuildPackage and the // IR program it builds in ../ir/builder_test.go. fset := token.NewFileSet() f, err := parser.ParseFile(fset, "hello.go", hello, parser.SkipObjectResolution) if err != nil { t.Fatal(err) } pkg := types.NewPackage("hello", "") irpkg, _, err := irutil.BuildPackage(&types.Config{Importer: importer.Default()}, fset, pkg, []*ast.File{f}, 0) if err != nil { t.Fatal(err) } if pkg.Name() != "main" { t.Errorf("pkg.Name() = %s, want main", pkg.Name()) } if irpkg.Func("main") == nil { irpkg.WriteTo(os.Stderr) t.Errorf("irpkg has no main function") } } func TestPackages(t *testing.T) { cfg := &packages.Config{Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles | packages.NeedImports | packages.NeedTypes | packages.NeedTypesSizes | packages.NeedSyntax | packages.NeedTypesInfo} initial, err := packages.Load(cfg, "bytes") if err != nil { t.Fatal(err) } if packages.PrintErrors(initial) > 0 { t.Fatal("there were errors") } prog, pkgs := irutil.Packages(initial, 0, nil) bytesNewBuffer := pkgs[0].Func("NewBuffer") bytesNewBuffer.Pkg.Build() // We'll dump the IR of bytes.NewBuffer because it is small and stable. out := new(bytes.Buffer) bytesNewBuffer.WriteTo(out) // For determinism, sanitize the location. location := prog.Fset.Position(bytesNewBuffer.Pos()).String() got := strings.Replace(out.String(), location, "$GOROOT/src/bytes/buffer.go:1", -1) want := ` # Name: bytes.NewBuffer # Package: bytes # Location: $GOROOT/src/bytes/buffer.go:1 func NewBuffer(buf []byte) *Buffer: b0: # entry t1 = Const {0} t2 = Const {0} t3 = Parameter <[]byte> {buf} t4 = HeapAlloc <*Buffer> # complit t5 = CompositeValue [100] t3 t1 t2 Store {bytes.Buffer} t4 t5 Jump → b1 b1: ← b0 # exit Return t4 `[1:] if got != want { t.Errorf("bytes.NewBuffer IR = <<%s>>, want <<%s>>", got, want) } } func TestBuildPackage_MissingImport(t *testing.T) { fset := token.NewFileSet() f, err := parser.ParseFile(fset, "bad.go", `package bad; import "missing"`, parser.SkipObjectResolution) if err != nil { t.Fatal(err) } pkg := types.NewPackage("bad", "") irpkg, _, err := irutil.BuildPackage(new(types.Config), fset, pkg, []*ast.File{f}, 0) if err == nil || irpkg != nil { t.Fatal("BuildPackage succeeded unexpectedly") } } func TestIssue28106(t *testing.T) { // In go1.10, go/packages loads all packages from source, not // export data, but does not type check function bodies of // imported packages. This test ensures that we do not attempt // to run the IR builder on functions without type information. cfg := &packages.Config{Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles | packages.NeedImports | packages.NeedTypes | packages.NeedTypesSizes | packages.NeedSyntax | packages.NeedTypesInfo} pkgs, err := packages.Load(cfg, "runtime") if err != nil { t.Fatal(err) } prog, _ := irutil.Packages(pkgs, 0, nil) prog.Build() // no crash } ������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/irutil/loops.go�������������������������������������������������0000664�0000000�0000000�00000002024�14657040722�0022104�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������package irutil import "honnef.co/go/tools/go/ir" type Loop struct{ *ir.BlockSet } func FindLoops(fn *ir.Function) []Loop { if fn.Blocks == nil { return nil } tree := fn.DomPreorder() var sets []Loop for _, h := range tree { for _, n := range h.Preds { if !h.Dominates(n) { continue } // n is a back-edge to h // h is the loop header if n == h { set := Loop{ir.NewBlockSet(len(fn.Blocks))} set.Add(n) sets = append(sets, set) continue } set := Loop{ir.NewBlockSet(len(fn.Blocks))} set.Add(h) set.Add(n) for _, b := range allPredsBut(n, h, nil) { set.Add(b) } sets = append(sets, set) } } return sets } func allPredsBut(b, but *ir.BasicBlock, list []*ir.BasicBlock) []*ir.BasicBlock { outer: for _, pred := range b.Preds { if pred == but { continue } for _, p := range list { // TODO improve big-o complexity of this function if pred == p { continue outer } } list = append(list, pred) list = allPredsBut(pred, but, list) } return list } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/irutil/stub.go��������������������������������������������������0000664�0000000�0000000�00000001515�14657040722�0021731�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������package irutil import ( "honnef.co/go/tools/go/ir" ) // IsStub reports whether a function is a stub. A function is // considered a stub if it has no instructions or if all it does is // return a constant value. func IsStub(fn *ir.Function) bool { for _, b := range fn.Blocks { for _, instr := range b.Instrs { switch instr.(type) { case *ir.Const: // const naturally has no side-effects case *ir.Panic: // panic is a stub if it only uses constants case *ir.Return: // return is a stub if it only uses constants case *ir.DebugRef: case *ir.Jump: // if there are no disallowed instructions, then we're // only jumping to the exit block (or possibly // somewhere else that's stubby?) default: // all other instructions are assumed to do actual work return false } } } return true } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/irutil/switch.go������������������������������������������������0000664�0000000�0000000�00000016423�14657040722�0022261�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright 2013 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. package irutil // This file implements discovery of switch and type-switch constructs // from low-level control flow. // // Many techniques exist for compiling a high-level switch with // constant cases to efficient machine code. The optimal choice will // depend on the data type, the specific case values, the code in the // body of each case, and the hardware. // Some examples: // - a lookup table (for a switch that maps constants to constants) // - a computed goto // - a binary tree // - a perfect hash // - a two-level switch (to partition constant strings by their first byte). import ( "bytes" "fmt" "go/token" "go/types" "honnef.co/go/tools/go/ir" ) // A ConstCase represents a single constant comparison. // It is part of a Switch. type ConstCase struct { Block *ir.BasicBlock // block performing the comparison Body *ir.BasicBlock // body of the case Value *ir.Const // case comparand } // A TypeCase represents a single type assertion. // It is part of a Switch. type TypeCase struct { Block *ir.BasicBlock // block performing the type assert Body *ir.BasicBlock // body of the case Type types.Type // case type Binding ir.Value // value bound by this case } // A Switch is a logical high-level control flow operation // (a multiway branch) discovered by analysis of a CFG containing // only if/else chains. It is not part of the ir.Instruction set. // // One of ConstCases and TypeCases has length >= 2; // the other is nil. // // In a value switch, the list of cases may contain duplicate constants. // A type switch may contain duplicate types, or types assignable // to an interface type also in the list. // TODO(adonovan): eliminate such duplicates. type Switch struct { Start *ir.BasicBlock // block containing start of if/else chain X ir.Value // the switch operand ConstCases []ConstCase // ordered list of constant comparisons TypeCases []TypeCase // ordered list of type assertions Default *ir.BasicBlock // successor if all comparisons fail } func (sw *Switch) String() string { // We represent each block by the String() of its // first Instruction, e.g. "print(42:int)". var buf bytes.Buffer if sw.ConstCases != nil { fmt.Fprintf(&buf, "switch %s {\n", sw.X.Name()) for _, c := range sw.ConstCases { fmt.Fprintf(&buf, "case %s: %s\n", c.Value.Name(), c.Body.Instrs[0]) } } else { fmt.Fprintf(&buf, "switch %s.(type) {\n", sw.X.Name()) for _, c := range sw.TypeCases { fmt.Fprintf(&buf, "case %s %s: %s\n", c.Binding.Name(), c.Type, c.Body.Instrs[0]) } } if sw.Default != nil { fmt.Fprintf(&buf, "default: %s\n", sw.Default.Instrs[0]) } fmt.Fprintf(&buf, "}") return buf.String() } // Switches examines the control-flow graph of fn and returns the // set of inferred value and type switches. A value switch tests an // ir.Value for equality against two or more compile-time constant // values. Switches involving link-time constants (addresses) are // ignored. A type switch type-asserts an ir.Value against two or // more types. // // The switches are returned in dominance order. // // The resulting switches do not necessarily correspond to uses of the // 'switch' keyword in the source: for example, a single source-level // switch statement with non-constant cases may result in zero, one or // many Switches, one per plural sequence of constant cases. // Switches may even be inferred from if/else- or goto-based control flow. // (In general, the control flow constructs of the source program // cannot be faithfully reproduced from the IR.) func Switches(fn *ir.Function) []Switch { // Traverse the CFG in dominance order, so we don't // enter an if/else-chain in the middle. var switches []Switch seen := make(map[*ir.BasicBlock]bool) // TODO(adonovan): opt: use ir.blockSet for _, b := range fn.DomPreorder() { if x, k := isComparisonBlock(b); x != nil { // Block b starts a switch. sw := Switch{Start: b, X: x} valueSwitch(&sw, k, seen) if len(sw.ConstCases) > 1 { switches = append(switches, sw) } } if y, x, T := isTypeAssertBlock(b); y != nil { // Block b starts a type switch. sw := Switch{Start: b, X: x} typeSwitch(&sw, y, T, seen) if len(sw.TypeCases) > 1 { switches = append(switches, sw) } } } return switches } func isSameX(x1 ir.Value, x2 ir.Value) bool { if x1 == x2 { return true } if x2, ok := x2.(*ir.Sigma); ok { return isSameX(x1, x2.X) } return false } func valueSwitch(sw *Switch, k *ir.Const, seen map[*ir.BasicBlock]bool) { b := sw.Start x := sw.X for isSameX(sw.X, x) { if seen[b] { break } seen[b] = true sw.ConstCases = append(sw.ConstCases, ConstCase{ Block: b, Body: b.Succs[0], Value: k, }) b = b.Succs[1] n := 0 for _, instr := range b.Instrs { switch instr.(type) { case *ir.If, *ir.BinOp: n++ case *ir.Sigma, *ir.Phi, *ir.DebugRef: default: n += 1000 } } if n != 2 { // Block b contains not just 'if x == k' and σ/ϕ nodes, // so it may have side effects that // make it unsafe to elide. break } if len(b.Preds) != 1 { // Block b has multiple predecessors, // so it cannot be treated as a case. break } x, k = isComparisonBlock(b) } sw.Default = b } func typeSwitch(sw *Switch, y ir.Value, T types.Type, seen map[*ir.BasicBlock]bool) { b := sw.Start x := sw.X for isSameX(sw.X, x) { if seen[b] { break } seen[b] = true sw.TypeCases = append(sw.TypeCases, TypeCase{ Block: b, Body: b.Succs[0], Type: T, Binding: y, }) b = b.Succs[1] n := 0 for _, instr := range b.Instrs { switch instr.(type) { case *ir.TypeAssert, *ir.Extract, *ir.If: n++ case *ir.Sigma, *ir.Phi: default: n += 1000 } } if n != 4 { // Block b contains not just // {TypeAssert; Extract #0; Extract #1; If} // so it may have side effects that // make it unsafe to elide. break } if len(b.Preds) != 1 { // Block b has multiple predecessors, // so it cannot be treated as a case. break } y, x, T = isTypeAssertBlock(b) } sw.Default = b } // isComparisonBlock returns the operands (v, k) if a block ends with // a comparison v==k, where k is a compile-time constant. func isComparisonBlock(b *ir.BasicBlock) (v ir.Value, k *ir.Const) { if n := len(b.Instrs); n >= 2 { if i, ok := b.Instrs[n-1].(*ir.If); ok { if binop, ok := i.Cond.(*ir.BinOp); ok && binop.Block() == b && binop.Op == token.EQL { if k, ok := binop.Y.(*ir.Const); ok { return binop.X, k } if k, ok := binop.X.(*ir.Const); ok { return binop.Y, k } } } } return } // isTypeAssertBlock returns the operands (y, x, T) if a block ends with // a type assertion "if y, ok := x.(T); ok {". func isTypeAssertBlock(b *ir.BasicBlock) (y, x ir.Value, T types.Type) { if n := len(b.Instrs); n >= 4 { if i, ok := b.Instrs[n-1].(*ir.If); ok { if ext1, ok := i.Cond.(*ir.Extract); ok && ext1.Block() == b && ext1.Index == 1 { if ta, ok := ext1.Tuple.(*ir.TypeAssert); ok && ta.Block() == b { // hack: relies upon instruction ordering. if ext0, ok := b.Instrs[n-3].(*ir.Extract); ok { return ext0, ta.X, ta.AssertedType } } } } } return } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/irutil/switch_test.go�������������������������������������������0000664�0000000�0000000�00000005406�14657040722�0023317�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright 2013 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. // No testdata on Android. //go:build !android // +build !android package irutil import ( "bytes" "fmt" "go/parser" "path/filepath" "strings" "testing" "honnef.co/go/tools/go/ir" "golang.org/x/tools/go/analysis/analysistest" //lint:ignore SA1019 go/loader is deprecated, but works fine for our tests "golang.org/x/tools/go/loader" ) func TestSwitches(t *testing.T) { conf := loader.Config{ParserMode: parser.ParseComments} f, err := conf.ParseFile(filepath.Join(analysistest.TestData(), "switches.go"), nil) if err != nil { t.Error(err) return } conf.CreateFromFiles("main", f) iprog, err := conf.Load() if err != nil { t.Error(err) return } prog := CreateProgram(iprog, 0) mainPkg := prog.Package(iprog.Created[0].Pkg) mainPkg.Build() for _, mem := range mainPkg.Members { if fn, ok := mem.(*ir.Function); ok { if fn.Synthetic != 0 { continue // e.g. init() } // Each (multi-line) "switch" comment within // this function must match the printed form // of a ConstSwitch. var wantSwitches []string for _, c := range f.Comments { if fn.Source().Pos() <= c.Pos() && c.Pos() < fn.Source().End() { text := strings.TrimSpace(c.Text()) if strings.HasPrefix(text, "switch ") { wantSwitches = append(wantSwitches, text) } } } switches := Switches(fn) if len(switches) != len(wantSwitches) { t.Errorf("in %s, found %d switches, want %d", fn, len(switches), len(wantSwitches)) } for i, sw := range switches { got := sw.testString() if i >= len(wantSwitches) { continue } want := wantSwitches[i] if got != want { t.Errorf("in %s, found switch %d: got <<%s>>, want <<%s>>", fn, i, got, want) } } } } } func (sw *Switch) testString() string { // same as the actual String method, but use the second to last // instruction instead, to skip over all the phi and sigma nodes // that SSI produces. var buf bytes.Buffer if sw.ConstCases != nil { fmt.Fprintf(&buf, "switch %s {\n", sw.X.Name()) for _, c := range sw.ConstCases { n := len(c.Body.Instrs) - 2 if n < 0 { n = 0 } fmt.Fprintf(&buf, "case %s: %s\n", c.Value.Name(), c.Body.Instrs[n]) } } else { fmt.Fprintf(&buf, "switch %s.(type) {\n", sw.X.Name()) for _, c := range sw.TypeCases { n := len(c.Body.Instrs) - 2 if n < 0 { n = 0 } fmt.Fprintf(&buf, "case %s %s: %s\n", c.Binding.Name(), c.Type, c.Body.Instrs[n]) } } if sw.Default != nil { n := len(sw.Default.Instrs) - 2 if n < 0 { n = 0 } fmt.Fprintf(&buf, "default: %s\n", sw.Default.Instrs[n]) } fmt.Fprintf(&buf, "}") return buf.String() } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/irutil/terminates.go��������������������������������������������0000664�0000000�0000000�00000003014�14657040722�0023123�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������package irutil import ( "go/types" "honnef.co/go/tools/go/ir" ) // Terminates reports whether fn is supposed to return, that is if it // has at least one theoretic path that returns from the function. // Explicit panics do not count as terminating. func Terminates(fn *ir.Function) bool { if fn.Blocks == nil { // assuming that a function terminates is the conservative // choice return true } for _, block := range fn.Blocks { if _, ok := block.Control().(*ir.Return); ok { if len(block.Preds) == 0 { return true } for _, pred := range block.Preds { switch ctrl := pred.Control().(type) { case *ir.Panic: // explicit panics do not count as terminating case *ir.If: // Check if we got here by receiving from a closed // time.Tick channel – this cannot happen at // runtime and thus doesn't constitute termination iff := ctrl if !ok { return true } ex, ok := iff.Cond.(*ir.Extract) if !ok { return true } if ex.Index != 1 { return true } recv, ok := ex.Tuple.(*ir.Recv) if !ok { return true } call, ok := recv.Chan.(*ir.Call) if !ok { return true } fn, ok := call.Common().Value.(*ir.Function) if !ok { return true } fn2, ok := fn.Object().(*types.Func) if !ok { return true } if fn2.FullName() != "time.Tick" { return true } default: // we've reached the exit block return true } } } } return false } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/irutil/testdata/������������������������������������������������0000775�0000000�0000000�00000000000�14657040722�0022234�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/irutil/testdata/switches.go�������������������������������������0000664�0000000�0000000�00000011015�14657040722�0024412�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������//go:build ignore // +build ignore package main // This file is the input to TestSwitches in switch_test.go. // Each multiway conditional with constant or type cases (Switch) // discovered by Switches is printed, and compared with the // comments. // // The body of each case is printed as the value of its first // instruction. // -------- Value switches -------- func four() int { return 4 } // A non-constant case makes a switch "impure", but its pure // cases form two separate switches. func SwitchWithNonConstantCase(x int) { // switch t12 { // case t1: Call <()> print t2 // case t3: Call <()> print t5 // case t4: Call <()> print t5 // default: BinOp {==} t30 t31 // } // switch t36 { // case t7: Call <()> print t8 // case t9: Call <()> print t10 // default: Call <()> print t11 // } switch x { case 1: print(1) case 2, 3: print(23) case four(): print(3) case 5: print(5) case 6: print(6) } print("done") } // Switches may be found even where the source // program doesn't have a switch statement. func ImplicitSwitches(x, y int) { // switch t13 { // case t1: Call <()> print t4 // case t2: Call <()> print t4 // default: BinOp {<} t28 t3 // } if x == 1 || 2 == x || x < 5 { print(12) } // switch t25 { // case t5: Call <()> print t7 // case t6: Call <()> print t7 // default: BinOp {==} t50 t51 // } if x == 3 || 4 == x || x == y { print(34) } // Not a switch: no consistent variable. if x == 5 || y == 6 { print(56) } // Not a switch: only one constant comparison. if x == 7 || x == y { print(78) } } func IfElseBasedSwitch(x int) { // switch t6 { // case t1: Call <()> print t2 // case t3: Call <()> print t4 // default: Call <()> print t5 // } if x == 1 { print(1) } else if x == 2 { print(2) } else { print("else") } } func GotoBasedSwitch(x int) { // switch t6 { // case t1: Call <()> print t4 // case t2: Call <()> print t5 // default: Call <()> print t3 // } if x == 1 { goto L1 } if x == 2 { goto L2 } print("else") L1: print(1) goto end L2: print(2) end: } func SwitchInAForLoop(x, y int) { // switch t13 { // case t2: Call <()> print t3 // case t4: Call <()> print t5 // default: BinOp {==} t31 t30 // } loop: for { print("head") switch x { case 1: print(1) break loop case 2: print(2) break loop case y: print(3) break loop } } } // This case is a switch in a for-loop, both constructed using goto. // As before, the default case points back to the block containing the // switch, but that's ok. func SwitchInAForLoopUsingGoto(x int) { // switch t10 { // case t2: Call <()> print t4 // case t3: Call <()> print t5 // default: BinOp {==} t10 t2 // } loop: print("head") if x == 1 { goto L1 } if x == 2 { goto L2 } goto loop L1: print(1) goto end L2: print(2) end: } func UnstructuredSwitchInAForLoop(x int) { // switch t9 { // case t1: Call <()> print t2 // case t3: BinOp {==} t9 t1 // default: Call <()> print t4 // } for { if x == 1 { print(1) return } if x == 2 { continue } break } print("end") } func CaseWithMultiplePreds(x int) { for { if x == 1 { print(1) return } loop: // This block has multiple predecessors, // so can't be treated as a switch case. if x == 2 { goto loop } break } print("end") } func DuplicateConstantsAreNotEliminated(x int) { // switch t7 { // case t1: Call <()> print t2 // case t3: Call <()> print t4 // case t5: Call <()> print t6 // default: Return // } if x == 1 { print(1) } else if x == 1 { // duplicate => unreachable print("1a") } else if x == 2 { print(2) } } // Interface values (created by comparisons) are not constants, // so ConstSwitch.X is never of interface type. func MakeInterfaceIsNotAConstant(x interface{}) { if x == "foo" { print("foo") } else if x == 1 { print(1) } } func ZeroInitializedVarsAreConstants(x int) { // switch t6 { // case t5: Call <()> print t1 // case t2: Call <()> print t3 // default: Call <()> print t4 // } var zero int // SSA construction replaces zero with 0 if x == zero { print(1) } else if x == 2 { print(2) } print("end") } // -------- Type switches -------- // NB, potentially fragile reliance on register number. func AdHocTypeSwitch(x interface{}) { // switch t2.(type) { // case t4 int: Call <()> println t8 // case t13 string: Call <()> println t16 // default: Call <()> print t1 // } if i, ok := x.(int); ok { println(i) } else if s, ok := x.(string); ok { println(s) } else { print("default") } } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/irutil/util.go��������������������������������������������������0000664�0000000�0000000�00000006210�14657040722�0021726�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������package irutil import ( "go/types" "strings" "honnef.co/go/tools/go/ir" "honnef.co/go/tools/go/types/typeutil" ) func Reachable(from, to *ir.BasicBlock) bool { if from == to { return true } if from.Dominates(to) { return true } found := false Walk(from, func(b *ir.BasicBlock) bool { if b == to { found = true return false } return true }) return found } func Walk(b *ir.BasicBlock, fn func(*ir.BasicBlock) bool) { seen := map[*ir.BasicBlock]bool{} wl := []*ir.BasicBlock{b} for len(wl) > 0 { b := wl[len(wl)-1] wl = wl[:len(wl)-1] if seen[b] { continue } seen[b] = true if !fn(b) { continue } wl = append(wl, b.Succs...) } } func Vararg(x *ir.Slice) ([]ir.Value, bool) { var out []ir.Value alloc, ok := ir.Unwrap(x.X).(*ir.Alloc) if !ok { return nil, false } var checkAlloc func(alloc ir.Value) bool checkAlloc = func(alloc ir.Value) bool { for _, ref := range *alloc.Referrers() { if ref == x { continue } if ref.Block() != x.Block() { return false } switch ref := ref.(type) { case *ir.IndexAddr: idx := ref if len(*idx.Referrers()) != 1 { return false } store, ok := (*idx.Referrers())[0].(*ir.Store) if !ok { return false } out = append(out, store.Val) case *ir.Copy: if !checkAlloc(ref) { return false } default: return false } } return true } if !checkAlloc(alloc) { return nil, false } return out, true } func CallName(call *ir.CallCommon) string { if call.IsInvoke() { return "" } switch v := call.Value.(type) { case *ir.Function: fn, ok := v.Object().(*types.Func) if !ok { return "" } return typeutil.FuncName(fn) case *ir.Builtin: return v.Name() } return "" } func IsCallTo(call *ir.CallCommon, name string) bool { return CallName(call) == name } func IsCallToAny(call *ir.CallCommon, names ...string) bool { q := CallName(call) for _, name := range names { if q == name { return true } } return false } func FilterDebug(instr []ir.Instruction) []ir.Instruction { var out []ir.Instruction for _, ins := range instr { if _, ok := ins.(*ir.DebugRef); !ok { out = append(out, ins) } } return out } func IsExample(fn *ir.Function) bool { if !strings.HasPrefix(fn.Name(), "Example") { return false } f := fn.Prog.Fset.File(fn.Pos()) if f == nil { return false } return strings.HasSuffix(f.Name(), "_test.go") } // Flatten recursively returns the underlying value of an ir.Sigma or // ir.Phi node. If all edges in an ir.Phi node are the same (after // flattening), the flattened edge will get returned. If flattening is // not possible, nil is returned. func Flatten(v ir.Value) ir.Value { failed := false seen := map[ir.Value]struct{}{} var out ir.Value var dfs func(v ir.Value) dfs = func(v ir.Value) { if failed { return } if _, ok := seen[v]; ok { return } seen[v] = struct{}{} switch v := v.(type) { case *ir.Sigma: dfs(v.X) case *ir.Phi: for _, e := range v.Edges { dfs(e) } default: if out == nil { out = v } else if out != v { failed = true } } } dfs(v) if failed { return nil } return out } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/irutil/visit.go�������������������������������������������������0000664�0000000�0000000�00000003763�14657040722�0022121�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright 2013 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. package irutil import "honnef.co/go/tools/go/ir" // This file defines utilities for visiting the IR of // a Program. // // TODO(adonovan): test coverage. // AllFunctions finds and returns the set of functions potentially // needed by program prog, as determined by a simple linker-style // reachability algorithm starting from the members and method-sets of // each package. The result may include anonymous functions and // synthetic wrappers. // // Precondition: all packages are built. func AllFunctions(prog *ir.Program) map[*ir.Function]bool { visit := visitor{ prog: prog, seen: make(map[*ir.Function]bool), } visit.program() return visit.seen } type visitor struct { prog *ir.Program seen map[*ir.Function]bool } func (visit *visitor) program() { for _, pkg := range visit.prog.AllPackages() { for _, mem := range pkg.Members { if fn, ok := mem.(*ir.Function); ok { visit.function(fn) } } } for _, T := range visit.prog.RuntimeTypes() { mset := visit.prog.MethodSets.MethodSet(T) for i, n := 0, mset.Len(); i < n; i++ { visit.function(visit.prog.MethodValue(mset.At(i))) } } } func (visit *visitor) function(fn *ir.Function) { if !visit.seen[fn] { visit.seen[fn] = true var buf [10]*ir.Value // avoid alloc in common case for _, b := range fn.Blocks { for _, instr := range b.Instrs { for _, op := range instr.Operands(buf[:0]) { if fn, ok := (*op).(*ir.Function); ok { visit.function(fn) } } } } } } // MainPackages returns the subset of the specified packages // named "main" that define a main function. // The result may include synthetic "testmain" packages. func MainPackages(pkgs []*ir.Package) []*ir.Package { var mains []*ir.Package for _, pkg := range pkgs { if pkg.Pkg.Name() == "main" && pkg.Func("main") != nil { mains = append(mains, pkg) } } return mains } �������������golang-honnef-go-tools-2024.1/go/ir/lift.go���������������������������������������������������������0000664�0000000�0000000�00000137712�14657040722�0020413�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright 2013 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. package ir // This file defines the lifting pass which tries to "lift" Alloc // cells (new/local variables) into SSA registers, replacing loads // with the dominating stored value, eliminating loads and stores, and // inserting φ- and σ-nodes as needed. // Cited papers and resources: // // Ron Cytron et al. 1991. Efficiently computing SSA form... // https://doi.acm.org/10.1145/115372.115320 // // Cooper, Harvey, Kennedy. 2001. A Simple, Fast Dominance Algorithm. // Software Practice and Experience 2001, 4:1-10. // https://www.hipersoft.rice.edu/grads/publications/dom14.pdf // // Daniel Berlin, llvmdev mailing list, 2012. // https://lists.cs.uiuc.edu/pipermail/llvmdev/2012-January/046638.html // (Be sure to expand the whole thread.) // // C. Scott Ananian. 1997. The static single information form. // // Jeremy Singer. 2006. Static program analysis based on virtual register renaming. // TODO(adonovan): opt: there are many optimizations worth evaluating, and // the conventional wisdom for SSA construction is that a simple // algorithm well engineered often beats those of better asymptotic // complexity on all but the most egregious inputs. // // Danny Berlin suggests that the Cooper et al. algorithm for // computing the dominance frontier is superior to Cytron et al. // Furthermore he recommends that rather than computing the DF for the // whole function then renaming all alloc cells, it may be cheaper to // compute the DF for each alloc cell separately and throw it away. // // Consider exploiting liveness information to avoid creating dead // φ-nodes which we then immediately remove. // // Also see many other "TODO: opt" suggestions in the code. import ( "encoding/binary" "fmt" "os" "slices" ) // If true, show diagnostic information at each step of lifting. // Very verbose. const debugLifting = false // domFrontier maps each block to the set of blocks in its dominance // frontier. The outer slice is conceptually a map keyed by // Block.Index. The inner slice is conceptually a set, possibly // containing duplicates. // // TODO(adonovan): opt: measure impact of dups; consider a packed bit // representation, e.g. big.Int, and bitwise parallel operations for // the union step in the Children loop. // // domFrontier's methods mutate the slice's elements but not its // length, so their receivers needn't be pointers. type domFrontier BlockMap[[]*BasicBlock] func (df domFrontier) add(u, v *BasicBlock) { df[u.Index] = append(df[u.Index], v) } // build builds the dominance frontier df for the dominator tree of // fn, using the algorithm found in A Simple, Fast Dominance // Algorithm, Figure 5. // // TODO(adonovan): opt: consider Berlin approach, computing pruned SSA // by pruning the entire IDF computation, rather than merely pruning // the DF -> IDF step. func (df domFrontier) build(fn *Function) { for _, b := range fn.Blocks { preds := b.Preds[0:len(b.Preds):len(b.Preds)] if b == fn.Exit { for i, v := range fn.fakeExits.values { if v { preds = append(preds, fn.Blocks[i]) } } } if len(preds) >= 2 { for _, p := range preds { runner := p for runner != b.dom.idom { df.add(runner, b) runner = runner.dom.idom } } } } } func buildDomFrontier(fn *Function) domFrontier { df := make(domFrontier, len(fn.Blocks)) df.build(fn) return df } type postDomFrontier BlockMap[[]*BasicBlock] func (rdf postDomFrontier) add(u, v *BasicBlock) { rdf[u.Index] = append(rdf[u.Index], v) } func (rdf postDomFrontier) build(fn *Function) { for _, b := range fn.Blocks { succs := b.Succs[0:len(b.Succs):len(b.Succs)] if fn.fakeExits.Has(b) { succs = append(succs, fn.Exit) } if len(succs) >= 2 { for _, s := range succs { runner := s for runner != b.pdom.idom { rdf.add(runner, b) runner = runner.pdom.idom } } } } } func buildPostDomFrontier(fn *Function) postDomFrontier { rdf := make(postDomFrontier, len(fn.Blocks)) rdf.build(fn) return rdf } func removeInstr(refs []Instruction, instr Instruction) []Instruction { return removeInstrsIf(refs, func(i Instruction) bool { return i == instr }) } func removeInstrsIf(refs []Instruction, p func(Instruction) bool) []Instruction { return slices.DeleteFunc(refs, p) } func clearInstrs(instrs []Instruction) { for i := range instrs { instrs[i] = nil } } func numberNodesPerBlock(f *Function) { for _, b := range f.Blocks { var base ID for _, instr := range b.Instrs { if instr == nil { continue } instr.setID(base) base++ } } } // lift replaces local and new Allocs accessed only with // load/store by IR registers, inserting φ- and σ-nodes where necessary. // The result is a program in pruned SSI form. // // Preconditions: // - fn has no dead blocks (blockopt has run). // - Def/use info (Operands and Referrers) is up-to-date. // - The dominator tree is up-to-date. func lift(fn *Function) bool { // TODO(adonovan): opt: lots of little optimizations may be // worthwhile here, especially if they cause us to avoid // buildDomFrontier. For example: // // - Alloc never loaded? Eliminate. // - Alloc never stored? Replace all loads with a zero constant. // - Alloc stored once? Replace loads with dominating store; // don't forget that an Alloc is itself an effective store // of zero. // - Alloc used only within a single block? // Use degenerate algorithm avoiding φ-nodes. // - Consider synergy with scalar replacement of aggregates (SRA). // e.g. *(&x.f) where x is an Alloc. // Perhaps we'd get better results if we generated this as x.f // i.e. Field(x, .f) instead of Load(FieldIndex(x, .f)). // Unclear. // // But we will start with the simplest correct code. var df domFrontier var rdf postDomFrontier var closure *closure var newPhis BlockMap[[]newPhi] var newSigmas BlockMap[[]newSigma] // During this pass we will replace some BasicBlock.Instrs // (allocs, loads and stores) with nil, keeping a count in // BasicBlock.gaps. At the end we will reset Instrs to the // concatenation of all non-dead newPhis and non-nil Instrs // for the block, reusing the original array if space permits. // While we're here, we also eliminate 'rundefers' // instructions and ssa:deferstack() in functions that contain no // 'defer' instructions. Eliminate ssa:deferstack() if it does not // escape. usesDefer := false deferstackAlloc, deferstackCall := deferstackPreamble(fn) eliminateDeferStack := deferstackAlloc != nil && !deferstackAlloc.Heap // Determine which allocs we can lift and number them densely. // The renaming phase uses this numbering for compact maps. numAllocs := 0 instructions := make(BlockMap[liftInstructions], len(fn.Blocks)) for i := range instructions { instructions[i].insertInstructions = map[Instruction][]Instruction{} } // Number nodes, for liftable numberNodesPerBlock(fn) for _, b := range fn.Blocks { b.gaps = 0 b.rundefers = 0 for _, instr := range b.Instrs { switch instr := instr.(type) { case *Alloc: if !liftable(instr, instructions) { instr.index = -1 continue } if numAllocs == 0 { df = buildDomFrontier(fn) rdf = buildPostDomFrontier(fn) if len(fn.Blocks) > 2 { closure = transitiveClosure(fn) } newPhis = make(BlockMap[[]newPhi], len(fn.Blocks)) newSigmas = make(BlockMap[[]newSigma], len(fn.Blocks)) if debugLifting { title := false for i, blocks := range df { if blocks != nil { if !title { fmt.Fprintf(os.Stderr, "Dominance frontier of %s:\n", fn) title = true } fmt.Fprintf(os.Stderr, "\t%s: %s\n", fn.Blocks[i], blocks) } } } } instr.index = numAllocs numAllocs++ case *Defer: usesDefer = true if eliminateDeferStack { // Clear _DeferStack and remove references to loads if instr._DeferStack != nil { if refs := instr._DeferStack.Referrers(); refs != nil { *refs = removeInstr(*refs, instr) } instr._DeferStack = nil } } case *RunDefers: b.rundefers++ } } } if numAllocs > 0 { for _, b := range fn.Blocks { work := instructions[b.Index] for _, rename := range work.renameAllocs { for _, instr_ := range b.Instrs[rename.startingAt:] { replace(instr_, rename.from, rename.to) } } } for _, b := range fn.Blocks { work := instructions[b.Index] if len(work.insertInstructions) != 0 { newInstrs := make([]Instruction, 0, len(fn.Blocks)+len(work.insertInstructions)*3) for _, instr := range b.Instrs { if add, ok := work.insertInstructions[instr]; ok { newInstrs = append(newInstrs, add...) } newInstrs = append(newInstrs, instr) } b.Instrs = newInstrs } } // TODO(dh): remove inserted allocs that end up unused after lifting. for _, b := range fn.Blocks { for _, instr := range b.Instrs { if instr, ok := instr.(*Alloc); ok && instr.index >= 0 { liftAlloc(closure, df, rdf, instr, newPhis, newSigmas) } } } // renaming maps an alloc (keyed by index) to its replacement // value. Initially the renaming contains nil, signifying the // zero constant of the appropriate type; we construct the // Const lazily at most once on each path through the domtree. // TODO(adonovan): opt: cache per-function not per subtree. renaming := make([]Value, numAllocs) // Renaming. rename(fn.Blocks[0], renaming, newPhis, newSigmas) simplifyPhisAndSigmas(newPhis, newSigmas) // Eliminate dead φ- and σ-nodes. markLiveNodes(fn.Blocks, newPhis, newSigmas) // Eliminate ssa:deferstack() call. if eliminateDeferStack { b := deferstackCall.block for i, instr := range b.Instrs { if instr == deferstackCall { b.Instrs[i] = nil b.gaps++ break } } } } // Prepend remaining live φ-nodes to each block and possibly kill rundefers. for _, b := range fn.Blocks { var head []Instruction if numAllocs > 0 { nps := newPhis[b.Index] head = make([]Instruction, 0, len(nps)) for _, pred := range b.Preds { nss := newSigmas[pred.Index] idx := pred.succIndex(b) for _, newSigma := range nss { if sigma := newSigma.sigmas[idx]; sigma != nil && sigma.live { head = append(head, sigma) // we didn't populate referrers before, as most // sigma nodes will be killed if refs := sigma.X.Referrers(); refs != nil { *refs = append(*refs, sigma) } } else if sigma != nil { sigma.block = nil } } } for _, np := range nps { if np.phi.live { head = append(head, np.phi) } else { for _, edge := range np.phi.Edges { if refs := edge.Referrers(); refs != nil { *refs = removeInstr(*refs, np.phi) } } np.phi.block = nil } } } rundefersToKill := b.rundefers if usesDefer { rundefersToKill = 0 } j := len(head) if j+b.gaps+rundefersToKill == 0 { continue // fast path: no new phis or gaps } // We could do straight copies instead of element-wise copies // when both b.gaps and rundefersToKill are zero. However, // that seems to only be the case ~1% of the time, which // doesn't seem worth the extra branch. // Remove dead instructions, add phis and sigmas ns := len(b.Instrs) + j - b.gaps - rundefersToKill if ns <= cap(b.Instrs) { // b.Instrs has enough capacity to store all instructions // OPT(dh): check cap vs the actually required space; if // there is a big enough difference, it may be worth // allocating a new slice, to avoid pinning memory. dst := b.Instrs[:cap(b.Instrs)] i := len(dst) - 1 for n := len(b.Instrs) - 1; n >= 0; n-- { instr := dst[n] if instr == nil { continue } if !usesDefer { if _, ok := instr.(*RunDefers); ok { continue } } dst[i] = instr i-- } off := i + 1 - len(head) // aid GC clearInstrs(dst[:off]) dst = dst[off:] copy(dst, head) b.Instrs = dst } else { // not enough space, so allocate a new slice and copy // over. dst := make([]Instruction, ns) copy(dst, head) for _, instr := range b.Instrs { if instr == nil { continue } if !usesDefer { if _, ok := instr.(*RunDefers); ok { continue } } dst[j] = instr j++ } b.Instrs = dst } } // Remove any fn.Locals that were lifted. j := 0 for _, l := range fn.Locals { if l.index < 0 { fn.Locals[j] = l j++ } } // Nil out fn.Locals[j:] to aid GC. for i := j; i < len(fn.Locals); i++ { fn.Locals[i] = nil } fn.Locals = fn.Locals[:j] return numAllocs > 0 } func hasDirectReferrer(instr Instruction) bool { for _, instr := range *instr.Referrers() { switch instr.(type) { case *Phi, *Sigma: // ignore default: return true } } return false } func markLiveNodes(blocks []*BasicBlock, newPhis BlockMap[[]newPhi], newSigmas BlockMap[[]newSigma]) { // Phis and sigmas may become dead due to optimization passes. We may also insert more nodes than strictly // necessary, e.g. sigma nodes for constants, which will never be used. // Phi and sigma nodes are considered live if a non-phi, non-sigma // node uses them. Once we find a node that is live, we mark all // of its operands as used, too. for _, npList := range newPhis { for _, np := range npList { phi := np.phi if !phi.live && hasDirectReferrer(phi) { markLivePhi(phi) } } } for _, npList := range newSigmas { for _, np := range npList { for _, sigma := range np.sigmas { if sigma != nil && !sigma.live && hasDirectReferrer(sigma) { markLiveSigma(sigma) } } } } // Existing φ-nodes due to && and || operators // are all considered live (see Go issue 19622). for _, b := range blocks { for _, phi := range b.phis() { markLivePhi(phi.(*Phi)) } } } func markLivePhi(phi *Phi) { phi.live = true for _, rand := range phi.Edges { switch rand := rand.(type) { case *Phi: if !rand.live { markLivePhi(rand) } case *Sigma: if !rand.live { markLiveSigma(rand) } } } } func markLiveSigma(sigma *Sigma) { sigma.live = true switch rand := sigma.X.(type) { case *Phi: if !rand.live { markLivePhi(rand) } case *Sigma: if !rand.live { markLiveSigma(rand) } } } // simplifyPhisAndSigmas removes duplicate phi and sigma nodes, // and replaces trivial phis with non-phi alternatives. Phi // nodes where all edges are identical, or consist of only the phi // itself and one other value, may be replaced with the value. func simplifyPhisAndSigmas(newPhis BlockMap[[]newPhi], newSigmas BlockMap[[]newSigma]) { // temporary numbering of values used in phis so that we can build map keys var id ID for _, npList := range newPhis { for _, np := range npList { for _, edge := range np.phi.Edges { edge.setID(id) id++ } } } // find all phis that are trivial and can be replaced with a // non-phi value. run until we reach a fixpoint, because replacing // a phi may make other phis trivial. for changed := true; changed; { changed = false for _, npList := range newPhis { for _, np := range npList { if np.phi.live { // we're reusing 'live' to mean 'dead' in the context of simplifyPhisAndSigmas continue } if r, ok := isUselessPhi(np.phi); ok { // useless phi, replace its uses with the // replacement value. the dead phi pass will clean // up the phi afterwards. replaceAll(np.phi, r) np.phi.live = true changed = true } } } // Replace duplicate sigma nodes with a single node. These nodes exist when multiple allocs get replaced with the // same dominating store. for _, sigmaList := range newSigmas { primarySigmas := map[struct { succ int v Value }]*Sigma{} for _, sigmas := range sigmaList { for succ, sigma := range sigmas.sigmas { if sigma == nil { continue } if sigma.live { // we're reusing 'live' to mean 'dead' in the context of simplifyPhisAndSigmas continue } key := struct { succ int v Value }{succ, sigma.X} if alt, ok := primarySigmas[key]; ok { replaceAll(sigma, alt) sigma.live = true changed = true } else { primarySigmas[key] = sigma } } } } // Replace duplicate phi nodes with a single node. As far as we know, these duplicate nodes only ever exist // because of the previous sigma deduplication. keyb := make([]byte, 0, 4*8) for _, npList := range newPhis { primaryPhis := map[string]*Phi{} for _, np := range npList { if np.phi.live { continue } if n := len(np.phi.Edges) * 8; cap(keyb) >= n { keyb = keyb[:n] } else { keyb = make([]byte, n, n*2) } for i, e := range np.phi.Edges { binary.LittleEndian.PutUint64(keyb[i*8:i*8+8], uint64(e.ID())) } if alt, ok := primaryPhis[string(keyb)]; ok { replaceAll(np.phi, alt) np.phi.live = true changed = true } else { primaryPhis[string(keyb)] = np.phi } } } } for _, npList := range newPhis { for _, np := range npList { np.phi.live = false for _, edge := range np.phi.Edges { edge.setID(0) } } } for _, sigmaList := range newSigmas { for _, sigmas := range sigmaList { for _, sigma := range sigmas.sigmas { if sigma != nil { sigma.live = false } } } } } type BlockSet struct { idx int values []bool count int } func NewBlockSet(size int) *BlockSet { return &BlockSet{values: make([]bool, size)} } func (s *BlockSet) Set(s2 *BlockSet) { copy(s.values, s2.values) s.count = 0 for _, v := range s.values { if v { s.count++ } } } func (s *BlockSet) Num() int { return s.count } func (s *BlockSet) Has(b *BasicBlock) bool { if b.Index >= len(s.values) { return false } return s.values[b.Index] } // add adds b to the set and returns true if the set changed. func (s *BlockSet) Add(b *BasicBlock) bool { if s.values[b.Index] { return false } s.count++ s.values[b.Index] = true s.idx = b.Index return true } func (s *BlockSet) Clear() { for j := range s.values { s.values[j] = false } s.count = 0 } // take removes an arbitrary element from a set s and // returns its index, or returns -1 if empty. func (s *BlockSet) Take() int { // [i, end] for i := s.idx; i < len(s.values); i++ { if s.values[i] { s.values[i] = false s.idx = i s.count-- return i } } // [start, i) for i := 0; i < s.idx; i++ { if s.values[i] { s.values[i] = false s.idx = i s.count-- return i } } return -1 } type closure struct { span []uint32 reachables BlockMap[interval] } type interval uint32 const ( flagMask = 1 << 31 numBits = 20 lengthBits = 32 - numBits - 1 lengthMask = (1<>numBits } else { // large interval i++ start = uint32(inv & numMask) end = uint32(r[i]) } if idx >= start && idx <= end { return true } } return false } func (c closure) reachable(id int) []interval { return c.reachables[c.span[id]:c.span[id+1]] } func (c closure) walk(current *BasicBlock, b *BasicBlock, visited []bool) { // TODO(dh): the 'current' argument seems to be unused // TODO(dh): there's no reason for this to be a method visited[b.Index] = true for _, succ := range b.Succs { if visited[succ.Index] { continue } visited[succ.Index] = true c.walk(current, succ, visited) } } func transitiveClosure(fn *Function) *closure { reachable := make(BlockMap[bool], len(fn.Blocks)) c := &closure{} c.span = make([]uint32, len(fn.Blocks)+1) addInterval := func(start, end uint32) { if l := end - start; l <= 1<= desc.firstUnliftable { continue } hasLiftable := false switch instr := instr.(type) { case *Store: if instr.Val != alloc { desc.hasLiftableOther = true hasLiftable = true } case *Load: desc.hasLiftableLoad = true hasLiftable = true case *DebugRef: desc.hasLiftableOther = true } if hasLiftable { if int(instr.ID()) > desc.lastLiftable { desc.lastLiftable = int(instr.ID()) } } } for i := range blocks { // Update firstUnliftable to be one after lastLiftable. We do this to include the unliftable's preceding // DebugRefs in the renaming. if blocks[i].lastLiftable == -1 && !blocks[i].storeInPreds { // There are no liftable instructions (for this alloc) in this block. Set firstUnliftable to the // first non-head instruction to avoid inserting the store before phi instructions, which would // fail validation. first := -1 instrLoop: for i, instr := range fn.Blocks[i].Instrs { switch instr.(type) { case *Phi, *Sigma: default: first = i break instrLoop } } blocks[i].firstUnliftable = first } else { blocks[i].firstUnliftable = blocks[i].lastLiftable + 1 } } // If a block is reachable by a (partially) unliftable block, then the entirety of the block is unliftable. In that // case, stores have to be inserted in the predecessors. // // TODO(dh): this isn't always necessary. If the block is reachable by itself, i.e. part of a loop, then if the // Alloc instruction is itself part of that loop, then there is a subset of instructions in the loop that can be // lifted. For example: // // for { // x := 42 // println(x) // escape(&x) // } // // The x that escapes in one iteration of the loop isn't the same x that we read from on the next iteration. seen := make(BlockMap[bool], len(fn.Blocks)) var dfs func(b *BasicBlock) dfs = func(b *BasicBlock) { if seen[b.Index] { return } seen[b.Index] = true desc := &blocks[b.Index] desc.hasLiftableLoad = false desc.hasLiftableOther = false desc.isUnliftable = true desc.firstUnliftable = 0 desc.storeInPreds = true for _, succ := range b.Succs { dfs(succ) } } for _, b := range fn.Blocks { if blocks[b.Index].isUnliftable { for _, succ := range b.Succs { dfs(succ) } } } hasLiftableLoad := false hasLiftableOther := false hasUnliftable := false for _, b := range fn.Blocks { desc := blocks[b.Index] hasLiftableLoad = hasLiftableLoad || desc.hasLiftableLoad hasLiftableOther = hasLiftableOther || desc.hasLiftableOther if desc.isUnliftable { hasUnliftable = true } } if !hasLiftableLoad && !hasLiftableOther { // There are no liftable uses return false } else if !hasUnliftable { // The alloc is entirely liftable without splitting return true } else if !hasLiftableLoad { // The alloc is not entirely liftable, and the only liftable uses are stores. While some of those stores could // get lifted away, it would also lead to an infinite loop when lifting to a fixpoint, because the newly created // allocs also get stored into repeatable and that's their only liftable uses. return false } // We need to insert stores for the new alloc. If a (partially) unliftable block has no unliftable // predecessors and the use isn't in a phi node, then the store can be inserted right before the unliftable use. // Otherwise, stores have to be inserted at the end of all liftable predecessors. newAlloc := &Alloc{Heap: true} newAlloc.setBlock(alloc.block) newAlloc.setType(alloc.typ) newAlloc.setSource(alloc.source) newAlloc.index = -1 newAlloc.comment = "split alloc" { work := instructions[alloc.block.Index] work.insertInstructions[alloc] = append(work.insertInstructions[alloc], newAlloc) } predHasStore := make(BlockMap[bool], len(fn.Blocks)) for _, b := range fn.Blocks { desc := &blocks[b.Index] bWork := &instructions[b.Index] if desc.isUnliftable { bWork.renameAllocs = append(bWork.renameAllocs, struct { from *Alloc to *Alloc startingAt int }{ alloc, newAlloc, int(desc.firstUnliftable), }) } if !desc.isUnliftable { continue } propagate := func(in *BasicBlock, before Instruction) { load := &Load{ X: alloc, } store := &Store{ Addr: newAlloc, Val: load, } load.setType(deref(alloc.typ)) load.setBlock(in) load.comment = "split alloc" store.setBlock(in) updateOperandReferrers(load) updateOperandReferrers(store) store.comment = "split alloc" entry := &instructions[in.Index] entry.insertInstructions[before] = append(entry.insertInstructions[before], load, store) } if desc.storeInPreds { // emit stores at the end of liftable preds for _, pred := range b.Preds { if blocks[pred.Index].isUnliftable { continue } if !alloc.block.Dominates(pred) { // Consider this cfg: // // 1 // /| // / | // ↙ ↓ // 2--→3 // // with an Alloc in block 2. It doesn't make sense to insert a store in block 1 for the jump to // block 3, because 1 can never see the Alloc in the first place. // // Ignoring phi nodes, an Alloc always dominates all of its uses, and phi nodes don't matter here, // because for the incoming edges that do matter, we do emit the stores. continue } if predHasStore[pred.Index] { // Don't generate redundant propagations. Not only is it unnecessary, it can lead to infinite loops // when trying to lift to a fix point, because redundant stores are liftable. continue } predHasStore[pred.Index] = true before := pred.Instrs[len(pred.Instrs)-1] propagate(pred, before) } } else { // emit store before the first unliftable use before := b.Instrs[desc.firstUnliftable] propagate(b, before) } } return true } // liftAlloc lifts alloc into registers and populates newPhis and newSigmas with all the φ- and σ-nodes it may require. func liftAlloc(closure *closure, df domFrontier, rdf postDomFrontier, alloc *Alloc, newPhis BlockMap[[]newPhi], newSigmas BlockMap[[]newSigma]) { fn := alloc.Parent() defblocks := fn.blockset(0) useblocks := fn.blockset(1) Aphi := fn.blockset(2) Asigma := fn.blockset(3) W := fn.blockset(4) // Compute defblocks, the set of blocks containing a // definition of the alloc cell. for _, instr := range *alloc.Referrers() { switch instr := instr.(type) { case *Store: defblocks.Add(instr.Block()) case *Load: useblocks.Add(instr.Block()) for _, ref := range *instr.Referrers() { useblocks.Add(ref.Block()) } } } // The Alloc itself counts as a (zero) definition of the cell. defblocks.Add(alloc.Block()) if debugLifting { fmt.Fprintln(os.Stderr, "\tlifting ", alloc, alloc.Name()) } // Φ-insertion. // // What follows is the body of the main loop of the insert-φ // function described by Cytron et al, but instead of using // counter tricks, we just reset the 'hasAlready' and 'work' // sets each iteration. These are bitmaps so it's pretty cheap. // Initialize W and work to defblocks. for change := true; change; { change = false { // Traverse iterated dominance frontier, inserting φ-nodes. W.Set(defblocks) for i := W.Take(); i != -1; i = W.Take() { n := fn.Blocks[i] for _, y := range df[n.Index] { if Aphi.Add(y) { if len(*alloc.Referrers()) == 0 { continue } live := false if closure == nil { live = true } else { for _, ref := range *alloc.Referrers() { if _, ok := ref.(*Load); ok { if closure.has(y, ref.Block()) { live = true break } } } } if !live { continue } // Create φ-node. // It will be prepended to v.Instrs later, if needed. if len(y.Preds) == 0 { // The exit block may be unreachable if the function doesn't // return, e.g. due to an infinite loop. In that case we // should not replace loads in the exit block with ϕ node that // have no edges. Such loads exist when the function has named // return parameters, as the exit block loads them to turn // them into a Return instruction. By not replacing the loads // with ϕ nodes, they will later be replaced by zero // constants. This is arguably more correct, and more // importantly, it doesn't break code that assumes that phis // have at least one edge. // // For one instance of breakage see // https://staticcheck.dev/issues/1533 continue } phi := &Phi{ Edges: make([]Value, len(y.Preds)), } phi.comment = alloc.comment phi.source = alloc.source phi.setType(deref(alloc.Type())) phi.block = y if debugLifting { fmt.Fprintf(os.Stderr, "\tplace %s = %s at block %s\n", phi.Name(), phi, y) } newPhis[y.Index] = append(newPhis[y.Index], newPhi{phi, alloc}) for _, p := range y.Preds { useblocks.Add(p) } change = true if defblocks.Add(y) { W.Add(y) } } } } } { W.Set(useblocks) for i := W.Take(); i != -1; i = W.Take() { n := fn.Blocks[i] for _, y := range rdf[n.Index] { if Asigma.Add(y) { sigmas := make([]*Sigma, 0, len(y.Succs)) anyLive := false for _, succ := range y.Succs { live := false for _, ref := range *alloc.Referrers() { if closure == nil || closure.has(succ, ref.Block()) { live = true anyLive = true break } } if live { sigma := &Sigma{ From: y, X: alloc, } sigma.comment = alloc.comment sigma.source = alloc.source sigma.setType(deref(alloc.Type())) sigma.block = succ sigmas = append(sigmas, sigma) } else { sigmas = append(sigmas, nil) } } if anyLive { newSigmas[y.Index] = append(newSigmas[y.Index], newSigma{alloc, sigmas}) for _, s := range y.Succs { defblocks.Add(s) } change = true if useblocks.Add(y) { W.Add(y) } } } } } } } } // replaceAll replaces all intraprocedural uses of x with y, // updating x.Referrers and y.Referrers. // Precondition: x.Referrers() != nil, i.e. x must be local to some function. func replaceAll(x, y Value) { var rands []*Value pxrefs := x.Referrers() pyrefs := y.Referrers() for _, instr := range *pxrefs { switch instr := instr.(type) { case *CompositeValue: // Special case CompositeValue because it might have very large lists of operands // // OPT(dh): this loop is still expensive for large composite values for i, rand := range instr.Values { if rand == x { instr.Values[i] = y } } default: rands = instr.Operands(rands[:0]) // recycle storage for _, rand := range rands { if *rand != nil { if *rand == x { *rand = y } } } } if pyrefs != nil { *pyrefs = append(*pyrefs, instr) // dups ok } } *pxrefs = nil // x is now unreferenced } func replace(instr Instruction, x, y Value) { args := instr.Operands(nil) matched := false for _, arg := range args { if *arg == x { *arg = y matched = true } } if matched { yrefs := y.Referrers() if yrefs != nil { *yrefs = append(*yrefs, instr) } xrefs := x.Referrers() if xrefs != nil { *xrefs = removeInstr(*xrefs, instr) } } } // renamed returns the value to which alloc is being renamed, // constructing it lazily if it's the implicit zero initialization. func renamed(fn *Function, renaming []Value, alloc *Alloc) Value { v := renaming[alloc.index] if v == nil { v = emitConst(fn, zeroConst(deref(alloc.Type()), alloc.source)) renaming[alloc.index] = v } return v } func copyValue(v Value, why Instruction, info CopyInfo) *Copy { c := &Copy{ X: v, Why: why, Info: info, } if refs := v.Referrers(); refs != nil { *refs = append(*refs, c) } c.setType(v.Type()) c.setSource(v.Source()) return c } func splitOnNewInformation(u *BasicBlock, renaming *StackMap) { renaming.Push() defer renaming.Pop() rename := func(v Value, why Instruction, info CopyInfo, i int) { c := copyValue(v, why, info) c.setBlock(u) renaming.Set(v, c) u.Instrs = append(u.Instrs, nil) copy(u.Instrs[i+2:], u.Instrs[i+1:]) u.Instrs[i+1] = c } replacement := func(v Value) (Value, bool) { r, ok := renaming.Get(v) if !ok { return nil, false } for { rr, ok := renaming.Get(r) if !ok { // Store replacement in the map so that future calls to replacement(v) don't have to go through the // iterative process again. renaming.Set(v, r) return r, true } r = rr } } var hasInfo func(v Value, info CopyInfo) bool hasInfo = func(v Value, info CopyInfo) bool { switch v := v.(type) { case *Copy: return (v.Info&info) == info || hasInfo(v.X, info) case *FieldAddr, *IndexAddr, *TypeAssert, *MakeChan, *MakeMap, *MakeSlice, *Alloc: return info == CopyInfoNotNil case Member, *Builtin: return info == CopyInfoNotNil case *Sigma: return hasInfo(v.X, info) default: return false } } var args []*Value for i := 0; i < len(u.Instrs); i++ { instr := u.Instrs[i] if instr == nil { continue } args = instr.Operands(args[:0]) for _, arg := range args { if *arg == nil { continue } if r, ok := replacement(*arg); ok { *arg = r replace(instr, *arg, r) } } // TODO write some bits on why we copy values instead of encoding the actual control flow and panics switch instr := instr.(type) { case *IndexAddr: // Note that we rename instr.Index and instr.X even if they're already copies, because unique combinations // of X and Index may lead to unique information. // OPT we should rename both variables at once and avoid one memmove rename(instr.Index, instr, CopyInfoNotNegative, i) rename(instr.X, instr, CopyInfoNotNil, i) i += 2 // skip over instructions we just inserted case *FieldAddr: if !hasInfo(instr.X, CopyInfoNotNil) { rename(instr.X, instr, CopyInfoNotNil, i) i++ } case *TypeAssert: // If we've already type asserted instr.X without comma-ok before, then it can only contain a single type, // and successive type assertions, no matter the type, don't tell us anything new. if !hasInfo(instr.X, CopyInfoNotNil|CopyInfoSingleConcreteType) { rename(instr.X, instr, CopyInfoNotNil|CopyInfoSingleConcreteType, i) i++ // skip over instruction we just inserted } case *Load: if !hasInfo(instr.X, CopyInfoNotNil) { rename(instr.X, instr, CopyInfoNotNil, i) i++ } case *Store: if !hasInfo(instr.Addr, CopyInfoNotNil) { rename(instr.Addr, instr, CopyInfoNotNil, i) i++ } case *MapUpdate: if !hasInfo(instr.Map, CopyInfoNotNil) { rename(instr.Map, instr, CopyInfoNotNil, i) i++ } case CallInstruction: off := 0 if !instr.Common().IsInvoke() && !hasInfo(instr.Common().Value, CopyInfoNotNil) { rename(instr.Common().Value, instr, CopyInfoNotNil, i) off++ } if f, ok := instr.Common().Value.(*Builtin); ok { switch f.name { case "close": arg := instr.Common().Args[0] if !hasInfo(arg, CopyInfoNotNil|CopyInfoClosed) { rename(arg, instr, CopyInfoNotNil|CopyInfoClosed, i) off++ } } } i += off case *SliceToArrayPointer: // A slice to array pointer conversion tells us the minimum length of the slice rename(instr.X, instr, CopyInfoUnspecified, i) i++ case *SliceToArray: // A slice to array conversion tells us the minimum length of the slice rename(instr.X, instr, CopyInfoUnspecified, i) i++ case *Slice: // Slicing tells us about some of the bounds off := 0 if instr.Low == nil && instr.High == nil && instr.Max == nil { // If all indices are unspecified, then we can only learn something about instr.X if it might've been // nil. if !hasInfo(instr.X, CopyInfoNotNil) { rename(instr.X, instr, CopyInfoUnspecified, i) off++ } } else { rename(instr.X, instr, CopyInfoUnspecified, i) off++ } // We copy the indices even if we already know they are not negative, because we can associate numeric // ranges with them. if instr.Low != nil { rename(instr.Low, instr, CopyInfoNotNegative, i) off++ } if instr.High != nil { rename(instr.High, instr, CopyInfoNotNegative, i) off++ } if instr.Max != nil { rename(instr.Max, instr, CopyInfoNotNegative, i) off++ } i += off case *StringLookup: rename(instr.X, instr, CopyInfoUnspecified, i) rename(instr.Index, instr, CopyInfoNotNegative, i) i += 2 case *Recv: if !hasInfo(instr.Chan, CopyInfoNotNil) { // Receiving from a nil channel never completes rename(instr.Chan, instr, CopyInfoNotNil, i) i++ } case *Send: if !hasInfo(instr.Chan, CopyInfoNotNil) { // Sending to a nil channel never completes. Sending to a closed channel panics, but whether a channel // is closed isn't local to this function, so we didn't learn anything. rename(instr.Chan, instr, CopyInfoNotNil, i) i++ } } } for _, v := range u.dom.children { splitOnNewInformation(v, renaming) } } // rename implements the Cytron et al-based SSI renaming algorithm, a // preorder traversal of the dominator tree replacing all loads of // Alloc cells with the value stored to that cell by the dominating // store instruction. // // renaming is a map from *Alloc (keyed by index number) to its // dominating stored value; newPhis[x] is the set of new φ-nodes to be // prepended to block x. func rename(u *BasicBlock, renaming []Value, newPhis BlockMap[[]newPhi], newSigmas BlockMap[[]newSigma]) { // Each φ-node becomes the new name for its associated Alloc. for _, np := range newPhis[u.Index] { phi := np.phi alloc := np.alloc renaming[alloc.index] = phi } // Rename loads and stores of allocs. for i, instr := range u.Instrs { switch instr := instr.(type) { case *Alloc: if instr.index >= 0 { // store of zero to Alloc cell // Replace dominated loads by the zero value. renaming[instr.index] = nil if debugLifting { fmt.Fprintf(os.Stderr, "\tkill alloc %s\n", instr) } // Delete the Alloc. u.Instrs[i] = nil u.gaps++ } case *Store: if alloc, ok := instr.Addr.(*Alloc); ok && alloc.index >= 0 { // store to Alloc cell // Replace dominated loads by the stored value. renaming[alloc.index] = instr.Val if debugLifting { fmt.Fprintf(os.Stderr, "\tkill store %s; new value: %s\n", instr, instr.Val.Name()) } if refs := instr.Addr.Referrers(); refs != nil { *refs = removeInstr(*refs, instr) } if refs := instr.Val.Referrers(); refs != nil { *refs = removeInstr(*refs, instr) } // Delete the Store. u.Instrs[i] = nil u.gaps++ } case *Load: if alloc, ok := instr.X.(*Alloc); ok && alloc.index >= 0 { // load of Alloc cell // In theory, we wouldn't be able to replace loads directly, because a loaded value could be used in // different branches, in which case it should be replaced with different sigma nodes. But we can't // simply defer replacement, either, because then later stores might incorrectly affect this load. // // To avoid doing renaming on _all_ values (instead of just loads and stores like we're doing), we make // sure during code generation that each load is only used in one block. For example, in constant switch // statements, where the tag is only evaluated once, we store it in a temporary and load it for each // comparison, so that we have individual loads to replace. // // Because we only rename stores and loads, the end result will not contain sigma nodes for all // constants. Some constants may be used directly, e.g. in comparisons such as 'x == 5'. We may still // end up inserting dead sigma nodes in branches, but these will never get used in renaming and will be // cleaned up when we remove dead phis and sigmas. newval := renamed(u.Parent(), renaming, alloc) if debugLifting { fmt.Fprintf(os.Stderr, "\tupdate load %s = %s with %s\n", instr.Name(), instr, newval) } replaceAll(instr, newval) u.Instrs[i] = nil u.gaps++ } case *DebugRef: if x, ok := instr.X.(*Alloc); ok && x.index >= 0 { if instr.IsAddr { instr.X = renamed(u.Parent(), renaming, x) instr.IsAddr = false // Add DebugRef to instr.X's referrers. if refs := instr.X.Referrers(); refs != nil { *refs = append(*refs, instr) } } else { // A source expression denotes the address // of an Alloc that was optimized away. instr.X = nil // Delete the DebugRef. u.Instrs[i] = nil u.gaps++ } } } } // update all outgoing sigma nodes with the dominating store for _, sigmas := range newSigmas[u.Index] { for _, sigma := range sigmas.sigmas { if sigma == nil { continue } sigma.X = renamed(u.Parent(), renaming, sigmas.alloc) } } // For each φ-node in a CFG successor, rename the edge. for succi, v := range u.Succs { phis := newPhis[v.Index] if len(phis) == 0 { continue } i := v.predIndex(u) for _, np := range phis { phi := np.phi alloc := np.alloc // if there's a sigma node, use it, else use the dominating value var newval Value for _, sigmas := range newSigmas[u.Index] { if sigmas.alloc == alloc && sigmas.sigmas[succi] != nil { newval = sigmas.sigmas[succi] break } } if newval == nil { newval = renamed(u.Parent(), renaming, alloc) } if debugLifting { fmt.Fprintf(os.Stderr, "\tsetphi %s edge %s -> %s (#%d) (alloc=%s) := %s\n", phi.Name(), u, v, i, alloc.Name(), newval.Name()) } phi.Edges[i] = newval if prefs := newval.Referrers(); prefs != nil { *prefs = append(*prefs, phi) } } } // Continue depth-first recursion over domtree, pushing a // fresh copy of the renaming map for each subtree. r := make([]Value, len(renaming)) for _, v := range u.dom.children { copy(r, renaming) // on entry to a block, the incoming sigma nodes become the new values for their alloc if idx := u.succIndex(v); idx != -1 { for _, sigma := range newSigmas[u.Index] { if sigma.sigmas[idx] != nil { r[sigma.alloc.index] = sigma.sigmas[idx] } } } rename(v, r, newPhis, newSigmas) } } func simplifyConstantCompositeValues(fn *Function) bool { changed := false for _, b := range fn.Blocks { n := 0 for _, instr := range b.Instrs { replaced := false if cv, ok := instr.(*CompositeValue); ok { ac := &AggregateConst{} ac.typ = cv.typ replaced = true for _, v := range cv.Values { if c, ok := v.(Constant); ok { ac.Values = append(ac.Values, c) } else { replaced = false break } } if replaced { replaceAll(cv, emitConst(fn, ac)) killInstruction(cv) } } if replaced { changed = true } else { b.Instrs[n] = instr n++ } } clearInstrs(b.Instrs[n:]) b.Instrs = b.Instrs[:n] } return changed } func updateOperandReferrers(instr Instruction) { for _, op := range instr.Operands(nil) { refs := (*op).Referrers() if refs != nil { *refs = append(*refs, instr) } } } // deferstackPreamble returns the *Alloc and ssa:deferstack() call for fn.deferstack. func deferstackPreamble(fn *Function) (*Alloc, *Call) { if alloc, _ := fn.vars[fn.deferstack].(*Alloc); alloc != nil { for _, ref := range *alloc.Referrers() { if ref, _ := ref.(*Store); ref != nil && ref.Addr == alloc { if call, _ := ref.Val.(*Call); call != nil { return alloc, call } } } } return nil, nil } ������������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/lvalue.go�������������������������������������������������������0000664�0000000�0000000�00000011144�14657040722�0020733�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright 2013 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. package ir // lvalues are the union of addressable expressions and map-index // expressions. import ( "go/ast" "go/types" ) // An lvalue represents an assignable location that may appear on the // left-hand side of an assignment. This is a generalization of a // pointer to permit updates to elements of maps. type lvalue interface { store(fn *Function, v Value, source ast.Node) // stores v into the location load(fn *Function, source ast.Node) Value // loads the contents of the location address(fn *Function) Value // address of the location typ() types.Type // returns the type of the location } // An address is an lvalue represented by a true pointer. type address struct { addr Value expr ast.Expr // source syntax of the value (not address) [debug mode] } func (a *address) load(fn *Function, source ast.Node) Value { return emitLoad(fn, a.addr, source) } func (a *address) store(fn *Function, v Value, source ast.Node) { store := emitStore(fn, a.addr, v, source) if a.expr != nil { // store.Val is v, converted for assignability. emitDebugRef(fn, a.expr, store.Val, false) } } func (a *address) address(fn *Function) Value { if a.expr != nil { emitDebugRef(fn, a.expr, a.addr, true) } return a.addr } func (a *address) typ() types.Type { return deref(a.addr.Type()) } type compositeElement struct { cv *CompositeValue idx int t types.Type expr ast.Expr } func (ce *compositeElement) load(fn *Function, source ast.Node) Value { panic("not implemented") } func (ce *compositeElement) store(fn *Function, v Value, source ast.Node) { v = emitConv(fn, v, ce.t, source) ce.cv.Values[ce.idx] = v if ce.expr != nil { // store.Val is v, converted for assignability. emitDebugRef(fn, ce.expr, v, false) } } func (ce *compositeElement) address(fn *Function) Value { panic("not implemented") } func (ce *compositeElement) typ() types.Type { return ce.t } // An element is an lvalue represented by m[k], the location of an // element of a map. These locations are not addressable // since pointers cannot be formed from them, but they do support // load() and store(). type element struct { m, k Value // map t types.Type // map element type } func (e *element) load(fn *Function, source ast.Node) Value { l := &MapLookup{ X: e.m, Index: e.k, } l.setType(e.t) return fn.emit(l, source) } func (e *element) store(fn *Function, v Value, source ast.Node) { up := &MapUpdate{ Map: e.m, Key: e.k, Value: emitConv(fn, v, e.t, source), } fn.emit(up, source) } func (e *element) address(fn *Function) Value { panic("map elements are not addressable") } func (e *element) typ() types.Type { return e.t } // A lazyAddress is an lvalue whose address is the result of an instruction. // These work like an *address except a new address.address() Value // is created on each load, store and address call. // A lazyAddress can be used to control when a side effect (nil pointer // dereference, index out of bounds) of using a location happens. type lazyAddress struct { addr func(fn *Function) Value // emit to fn the computation of the address t types.Type // type of the location expr ast.Expr // source syntax of the value (not address) [debug mode] } func (l *lazyAddress) load(fn *Function, source ast.Node) Value { load := emitLoad(fn, l.addr(fn), source) return load } func (l *lazyAddress) store(fn *Function, v Value, source ast.Node) { store := emitStore(fn, l.addr(fn), v, source) if l.expr != nil { // store.Val is v, converted for assignability. emitDebugRef(fn, l.expr, store.Val, false) } } func (l *lazyAddress) address(fn *Function) Value { addr := l.addr(fn) if l.expr != nil { emitDebugRef(fn, l.expr, addr, true) } return addr } func (l *lazyAddress) typ() types.Type { return l.t } // A blank is a dummy variable whose name is "_". // It is not reified: loads are illegal and stores are ignored. type blank struct{} func (bl blank) load(fn *Function, source ast.Node) Value { panic("blank.load is illegal") } func (bl blank) store(fn *Function, v Value, source ast.Node) { s := &BlankStore{ Val: v, } fn.emit(s, source) } func (bl blank) address(fn *Function) Value { panic("blank var is not addressable") } func (bl blank) typ() types.Type { // This should be the type of the blank Ident; the typechecker // doesn't provide this yet, but fortunately, we don't need it // yet either. panic("blank.typ is unimplemented") } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/methods.go������������������������������������������������������0000664�0000000�0000000�00000015320�14657040722�0021106�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright 2013 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. package ir // This file defines utilities for population of method sets. import ( "fmt" "go/types" "honnef.co/go/tools/analysis/lint" ) // MethodValue returns the Function implementing method sel, building // wrapper methods on demand. It returns nil if sel denotes an // abstract (interface) method. // // Precondition: sel.Kind() == MethodVal. // // Thread-safe. // // EXCLUSIVE_LOCKS_ACQUIRED(prog.methodsMu) func (prog *Program) MethodValue(sel *types.Selection) *Function { if sel.Kind() != types.MethodVal { panic(fmt.Sprintf("MethodValue(%s) kind != MethodVal", sel)) } T := sel.Recv() if types.IsInterface(T) { return nil // abstract method } if prog.mode&LogSource != 0 { defer logStack("MethodValue %s %v", T, sel)() } prog.methodsMu.Lock() defer prog.methodsMu.Unlock() return prog.addMethod(prog.createMethodSet(T), sel) } // LookupMethod returns the implementation of the method of type T // identified by (pkg, name). It returns nil if the method exists but // is abstract, and panics if T has no such method. func (prog *Program) LookupMethod(T types.Type, pkg *types.Package, name string) *Function { sel := prog.MethodSets.MethodSet(T).Lookup(pkg, name) if sel == nil { panic(fmt.Sprintf("%s has no method %s", T, types.Id(pkg, name))) } return prog.MethodValue(sel) } // methodSet contains the (concrete) methods of a non-interface type. type methodSet struct { mapping map[string]*Function // populated lazily complete bool // mapping contains all methods } // Precondition: !isInterface(T). // EXCLUSIVE_LOCKS_REQUIRED(prog.methodsMu) func (prog *Program) createMethodSet(T types.Type) *methodSet { mset, ok := prog.methodSets.At(T) if !ok { mset = &methodSet{mapping: make(map[string]*Function)} prog.methodSets.Set(T, mset) } return mset } // EXCLUSIVE_LOCKS_REQUIRED(prog.methodsMu) func (prog *Program) addMethod(mset *methodSet, sel *types.Selection) *Function { if sel.Kind() == types.MethodExpr { panic(sel) } id := sel.Obj().Id() fn := mset.mapping[id] if fn == nil { obj := sel.Obj().(*types.Func) needsPromotion := len(sel.Index()) > 1 needsIndirection := !isPointer(recvType(obj)) && isPointer(sel.Recv()) if needsPromotion || needsIndirection { fn = makeWrapper(prog, sel) } else { fn = prog.declaredFunc(obj) } if fn.Signature.Recv() == nil { panic(fn) // missing receiver } mset.mapping[id] = fn } return fn } // RuntimeTypes returns a new unordered slice containing all // concrete types in the program for which a complete (non-empty) // method set is required at run-time. // // Thread-safe. // // EXCLUSIVE_LOCKS_ACQUIRED(prog.methodsMu) func (prog *Program) RuntimeTypes() []types.Type { prog.methodsMu.Lock() defer prog.methodsMu.Unlock() var res []types.Type prog.methodSets.Iterate(func(T types.Type, v *methodSet) { if v.complete { res = append(res, T) } }) return res } // declaredFunc returns the concrete function/method denoted by obj. // Panic ensues if there is none. func (prog *Program) declaredFunc(obj *types.Func) *Function { if origin := obj.Origin(); origin != obj { // Calling method on instantiated type, create a wrapper that calls the generic type's method base := prog.packageLevelValue(origin) return makeInstance(prog, base.(*Function), obj.Type().(*types.Signature), nil) } else { if v := prog.packageLevelValue(obj); v != nil { return v.(*Function) } } panic("no concrete method: " + obj.String()) } // needMethodsOf ensures that runtime type information (including the // complete method set) is available for the specified type T and all // its subcomponents. // // needMethodsOf must be called for at least every type that is an // operand of some MakeInterface instruction, and for the type of // every exported package member. // // Precondition: T is not a method signature (*Signature with Recv()!=nil). // // Thread-safe. (Called via emitConv from multiple builder goroutines.) // // TODO(adonovan): make this faster. It accounts for 20% of SSA build time. // // EXCLUSIVE_LOCKS_ACQUIRED(prog.methodsMu) func (prog *Program) needMethodsOf(T types.Type) { prog.methodsMu.Lock() prog.needMethods(T, false) prog.methodsMu.Unlock() } // Precondition: T is not a method signature (*Signature with Recv()!=nil). // Recursive case: skip => don't create methods for T. // // EXCLUSIVE_LOCKS_REQUIRED(prog.methodsMu) func (prog *Program) needMethods(T types.Type, skip bool) { // Each package maintains its own set of types it has visited. if prevSkip, ok := prog.runtimeTypes.At(T); ok { // needMethods(T) was previously called if !prevSkip || skip { return // already seen, with same or false 'skip' value } } prog.runtimeTypes.Set(T, skip) tmset := prog.MethodSets.MethodSet(T) if !skip && !types.IsInterface(T) && tmset.Len() > 0 { // Create methods of T. mset := prog.createMethodSet(T) if !mset.complete { mset.complete = true n := tmset.Len() for i := 0; i < n; i++ { prog.addMethod(mset, tmset.At(i)) } } } // Recursion over signatures of each method. for i := 0; i < tmset.Len(); i++ { sig := tmset.At(i).Type().(*types.Signature) prog.needMethods(sig.Params(), false) prog.needMethods(sig.Results(), false) } switch t := T.(type) { case *types.Basic: // nop case *types.Interface, *types.TypeParam: // nop---handled by recursion over method set. case *types.Pointer: prog.needMethods(t.Elem(), false) case *types.Slice: prog.needMethods(t.Elem(), false) case *types.Chan: prog.needMethods(t.Elem(), false) case *types.Map: prog.needMethods(t.Key(), false) prog.needMethods(t.Elem(), false) case *types.Signature: if t.Recv() != nil { panic(fmt.Sprintf("Signature %s has Recv %s", t, t.Recv())) } prog.needMethods(t.Params(), false) prog.needMethods(t.Results(), false) case *types.Named: // A pointer-to-named type can be derived from a named // type via reflection. It may have methods too. prog.needMethods(types.NewPointer(t), false) // Consider 'type T struct{S}' where S has methods. // Reflection provides no way to get from T to struct{S}, // only to S, so the method set of struct{S} is unwanted, // so set 'skip' flag during recursion. prog.needMethods(t.Underlying(), true) case *types.Array: prog.needMethods(t.Elem(), false) case *types.Struct: for i, n := 0, t.NumFields(); i < n; i++ { prog.needMethods(t.Field(i).Type(), false) } case *types.Tuple: for i, n := 0, t.Len(); i < n; i++ { prog.needMethods(t.At(i).Type(), false) } case *types.Alias: prog.needMethods(types.Unalias(t), false) default: lint.ExhaustiveTypeSwitch(T) } } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/mode.go���������������������������������������������������������0000664�0000000�0000000�00000005624�14657040722�0020375�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// 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. package ir // This file defines the BuilderMode type and its command-line flag. import ( "bytes" "fmt" ) // BuilderMode is a bitmask of options for diagnostics and checking. // // *BuilderMode satisfies the flag.Value interface. Example: // // var mode = ir.BuilderMode(0) // func init() { flag.Var(&mode, "build", ir.BuilderModeDoc) } type BuilderMode uint const ( PrintPackages BuilderMode = 1 << iota // Print package inventory to stdout PrintFunctions // Print function IR code to stdout PrintSource // Print source code when printing function IR LogSource // Log source locations as IR builder progresses SanityCheckFunctions // Perform sanity checking of function bodies NaiveForm // Build naïve IR form: don't replace local loads/stores with registers GlobalDebug // Enable debug info for all packages SplitAfterNewInformation // Split live range after we learn something new about a value ) const BuilderModeDoc = `Options controlling the IR builder. The value is a sequence of zero or more of these symbols: C perform sanity [C]hecking of the IR form. D include [D]ebug info for every function. P print [P]ackage inventory. F print [F]unction IR code. A print [A]ST nodes responsible for IR instructions S log [S]ource locations as IR builder progresses. N build [N]aive IR form: don't replace local loads/stores with registers. I Split live range after a value is used as slice or array index ` func (m BuilderMode) String() string { var buf bytes.Buffer if m&GlobalDebug != 0 { buf.WriteByte('D') } if m&PrintPackages != 0 { buf.WriteByte('P') } if m&PrintFunctions != 0 { buf.WriteByte('F') } if m&PrintSource != 0 { buf.WriteByte('A') } if m&LogSource != 0 { buf.WriteByte('S') } if m&SanityCheckFunctions != 0 { buf.WriteByte('C') } if m&NaiveForm != 0 { buf.WriteByte('N') } if m&SplitAfterNewInformation != 0 { buf.WriteByte('I') } return buf.String() } // Set parses the flag characters in s and updates *m. func (m *BuilderMode) Set(s string) error { var mode BuilderMode for _, c := range s { switch c { case 'D': mode |= GlobalDebug case 'P': mode |= PrintPackages case 'F': mode |= PrintFunctions case 'A': mode |= PrintSource case 'S': mode |= LogSource case 'C': mode |= SanityCheckFunctions case 'N': mode |= NaiveForm case 'I': mode |= SplitAfterNewInformation default: return fmt.Errorf("unknown BuilderMode option: %q", c) } } *m = mode return nil } // Get returns m. func (m BuilderMode) Get() interface{} { return m } ������������������������������������������������������������������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/print.go��������������������������������������������������������0000664�0000000�0000000�00000034315�14657040722�0020604�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright 2013 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. package ir // This file implements the String() methods for all Value and // Instruction types. import ( "bytes" "fmt" "go/types" "io" "reflect" "sort" "strings" "honnef.co/go/tools/go/types/typeutil" ) // relName returns the name of v relative to i. // In most cases, this is identical to v.Name(), but references to // Functions (including methods) and Globals use RelString and // all types are displayed with relType, so that only cross-package // references are package-qualified. func relName(v Value, i Instruction) string { if v == nil { return "" } var from *types.Package if i != nil { from = i.Parent().pkg() } switch v := v.(type) { case Member: // *Function or *Global return v.RelString(from) } return v.Name() } func relType(t types.Type, from *types.Package) string { return types.TypeString(t, types.RelativeTo(from)) } func relTerm(term *types.Term, from *types.Package) string { s := relType(term.Type(), from) if term.Tilde() { return "~" + s } return s } func relString(m Member, from *types.Package) string { // NB: not all globals have an Object (e.g. init$guard), // so use Package().Object not Object.Package(). if pkg := m.Package().Pkg; pkg != nil && pkg != from { return fmt.Sprintf("%s.%s", pkg.Path(), m.Name()) } return m.Name() } // Value.String() // // This method is provided only for debugging. // It never appears in disassembly, which uses Value.Name(). func (v *Parameter) String() string { from := v.Parent().pkg() return fmt.Sprintf("Parameter <%s> {%s}", relType(v.Type(), from), v.name) } func (v *FreeVar) String() string { from := v.Parent().pkg() return fmt.Sprintf("FreeVar <%s> %s", relType(v.Type(), from), v.Name()) } func (v *Builtin) String() string { return fmt.Sprintf("Builtin %s", v.Name()) } // Instruction.String() func (v *Alloc) String() string { from := v.Parent().pkg() storage := "Stack" if v.Heap { storage = "Heap" } return fmt.Sprintf("%sAlloc <%s>", storage, relType(v.Type(), from)) } func (v *Sigma) String() string { from := v.Parent().pkg() s := fmt.Sprintf("Sigma <%s> [b%d] %s", relType(v.Type(), from), v.From.Index, v.X.Name()) return s } func (v *Phi) String() string { var b bytes.Buffer fmt.Fprintf(&b, "Phi <%s>", v.Type()) for i, edge := range v.Edges { b.WriteString(" ") // Be robust against malformed CFG. if v.block == nil { b.WriteString("??") continue } block := -1 if i < len(v.block.Preds) { block = v.block.Preds[i].Index } fmt.Fprintf(&b, "%d:", block) edgeVal := "" // be robust if edge != nil { edgeVal = relName(edge, v) } b.WriteString(edgeVal) } return b.String() } func printCall(v *CallCommon, prefix string, instr Instruction) string { var b bytes.Buffer if !v.IsInvoke() { if value, ok := instr.(Value); ok { fmt.Fprintf(&b, "%s <%s> %s", prefix, relType(value.Type(), instr.Parent().pkg()), relName(v.Value, instr)) } else { fmt.Fprintf(&b, "%s %s", prefix, relName(v.Value, instr)) } } else { if value, ok := instr.(Value); ok { fmt.Fprintf(&b, "%sInvoke <%s> %s.%s", prefix, relType(value.Type(), instr.Parent().pkg()), relName(v.Value, instr), v.Method.Name()) } else { fmt.Fprintf(&b, "%sInvoke %s.%s", prefix, relName(v.Value, instr), v.Method.Name()) } } for _, arg := range v.TypeArgs { b.WriteString(" ") b.WriteString(relType(arg, instr.Parent().pkg())) } for _, arg := range v.Args { b.WriteString(" ") b.WriteString(relName(arg, instr)) } return b.String() } func (c *CallCommon) String() string { return printCall(c, "", nil) } func (v *Call) String() string { return printCall(&v.Call, "Call", v) } func (v *BinOp) String() string { return fmt.Sprintf("BinOp <%s> {%s} %s %s", relType(v.Type(), v.Parent().pkg()), v.Op.String(), relName(v.X, v), relName(v.Y, v)) } func (v *UnOp) String() string { return fmt.Sprintf("UnOp <%s> {%s} %s", relType(v.Type(), v.Parent().pkg()), v.Op.String(), relName(v.X, v)) } func (v *Load) String() string { return fmt.Sprintf("Load <%s> %s", relType(v.Type(), v.Parent().pkg()), relName(v.X, v)) } func (v *Copy) String() string { return fmt.Sprintf("Copy <%s> %s", relType(v.Type(), v.Parent().pkg()), relName(v.X, v)) } func printConv(prefix string, v, x Value) string { from := v.Parent().pkg() return fmt.Sprintf("%s <%s> %s", prefix, relType(v.Type(), from), relName(x, v.(Instruction))) } func (v *ChangeType) String() string { return printConv("ChangeType", v, v.X) } func (v *Convert) String() string { return printConv("Convert", v, v.X) } func (v *ChangeInterface) String() string { return printConv("ChangeInterface", v, v.X) } func (v *SliceToArrayPointer) String() string { return printConv("SliceToArrayPointer", v, v.X) } func (v *SliceToArray) String() string { return printConv("SliceToArray", v, v.X) } func (v *MakeInterface) String() string { return printConv("MakeInterface", v, v.X) } func (v *MakeClosure) String() string { from := v.Parent().pkg() var b bytes.Buffer fmt.Fprintf(&b, "MakeClosure <%s> %s", relType(v.Type(), from), relName(v.Fn, v)) if v.Bindings != nil { for _, c := range v.Bindings { b.WriteString(" ") b.WriteString(relName(c, v)) } } return b.String() } func (v *MakeSlice) String() string { from := v.Parent().pkg() return fmt.Sprintf("MakeSlice <%s> %s %s", relType(v.Type(), from), relName(v.Len, v), relName(v.Cap, v)) } func (v *Slice) String() string { from := v.Parent().pkg() return fmt.Sprintf("Slice <%s> %s %s %s %s", relType(v.Type(), from), relName(v.X, v), relName(v.Low, v), relName(v.High, v), relName(v.Max, v)) } func (v *MakeMap) String() string { res := "" if v.Reserve != nil { res = relName(v.Reserve, v) } from := v.Parent().pkg() return fmt.Sprintf("MakeMap <%s> %s", relType(v.Type(), from), res) } func (v *MakeChan) String() string { from := v.Parent().pkg() return fmt.Sprintf("MakeChan <%s> %s", relType(v.Type(), from), relName(v.Size, v)) } func (v *FieldAddr) String() string { from := v.Parent().pkg() // v.X.Type() might be a pointer to a type parameter whose core type is a pointer to a struct st := deref(typeutil.CoreType(deref(v.X.Type()))).Underlying().(*types.Struct) // Be robust against a bad index. name := "?" if 0 <= v.Field && v.Field < st.NumFields() { name = st.Field(v.Field).Name() } return fmt.Sprintf("FieldAddr <%s> [%d] (%s) %s", relType(v.Type(), from), v.Field, name, relName(v.X, v)) } func (v *Field) String() string { st := typeutil.CoreType(v.X.Type()).Underlying().(*types.Struct) // Be robust against a bad index. name := "?" if 0 <= v.Field && v.Field < st.NumFields() { name = st.Field(v.Field).Name() } from := v.Parent().pkg() return fmt.Sprintf("Field <%s> [%d] (%s) %s", relType(v.Type(), from), v.Field, name, relName(v.X, v)) } func (v *IndexAddr) String() string { from := v.Parent().pkg() return fmt.Sprintf("IndexAddr <%s> %s %s", relType(v.Type(), from), relName(v.X, v), relName(v.Index, v)) } func (v *Index) String() string { from := v.Parent().pkg() return fmt.Sprintf("Index <%s> %s %s", relType(v.Type(), from), relName(v.X, v), relName(v.Index, v)) } func (v *MapLookup) String() string { from := v.Parent().pkg() return fmt.Sprintf("MapLookup <%s> %s %s", relType(v.Type(), from), relName(v.X, v), relName(v.Index, v)) } func (v *StringLookup) String() string { from := v.Parent().pkg() return fmt.Sprintf("StringLookup <%s> %s %s", relType(v.Type(), from), relName(v.X, v), relName(v.Index, v)) } func (v *Range) String() string { from := v.Parent().pkg() return fmt.Sprintf("Range <%s> %s", relType(v.Type(), from), relName(v.X, v)) } func (v *Next) String() string { from := v.Parent().pkg() return fmt.Sprintf("Next <%s> %s", relType(v.Type(), from), relName(v.Iter, v)) } func (v *TypeAssert) String() string { from := v.Parent().pkg() return fmt.Sprintf("TypeAssert <%s> %s", relType(v.Type(), from), relName(v.X, v)) } func (v *Extract) String() string { from := v.Parent().pkg() name := v.Tuple.Type().(*types.Tuple).At(v.Index).Name() return fmt.Sprintf("Extract <%s> [%d] (%s) %s", relType(v.Type(), from), v.Index, name, relName(v.Tuple, v)) } func (s *Jump) String() string { // Be robust against malformed CFG. block := -1 if s.block != nil && len(s.block.Succs) == 1 { block = s.block.Succs[0].Index } str := fmt.Sprintf("Jump → b%d", block) if s.Comment() != "" { str = fmt.Sprintf("%s # %s", str, s.Comment()) } return str } func (s *Unreachable) String() string { // Be robust against malformed CFG. block := -1 if s.block != nil && len(s.block.Succs) == 1 { block = s.block.Succs[0].Index } return fmt.Sprintf("Unreachable → b%d", block) } func (s *If) String() string { // Be robust against malformed CFG. tblock, fblock := -1, -1 if s.block != nil && len(s.block.Succs) == 2 { tblock = s.block.Succs[0].Index fblock = s.block.Succs[1].Index } return fmt.Sprintf("If %s → b%d b%d", relName(s.Cond, s), tblock, fblock) } func (s *ConstantSwitch) String() string { var b bytes.Buffer fmt.Fprintf(&b, "ConstantSwitch %s", relName(s.Tag, s)) for _, cond := range s.Conds { fmt.Fprintf(&b, " %s", relName(cond, s)) } fmt.Fprint(&b, " →") for _, succ := range s.block.Succs { fmt.Fprintf(&b, " b%d", succ.Index) } return b.String() } func (v *CompositeValue) String() string { var b bytes.Buffer from := v.Parent().pkg() fmt.Fprintf(&b, "CompositeValue <%s>", relType(v.Type(), from)) if v.NumSet >= len(v.Values) { // All values provided fmt.Fprint(&b, " [all]") } else if v.Bitmap.BitLen() == 0 { // No values provided fmt.Fprint(&b, " [none]") } else { // Some values provided bits := []byte(fmt.Sprintf("%0*b", len(v.Values), &v.Bitmap)) for i := 0; i < len(bits)/2; i++ { o := len(bits) - 1 - i bits[i], bits[o] = bits[o], bits[i] } fmt.Fprintf(&b, " [%s]", bits) } for _, vv := range v.Values { fmt.Fprintf(&b, " %s", relName(vv, v)) } return b.String() } func (s *TypeSwitch) String() string { from := s.Parent().pkg() var b bytes.Buffer fmt.Fprintf(&b, "TypeSwitch <%s> %s", relType(s.typ, from), relName(s.Tag, s)) for _, cond := range s.Conds { fmt.Fprintf(&b, " %q", relType(cond, s.block.parent.pkg())) } return b.String() } func (s *Go) String() string { return printCall(&s.Call, "Go", s) } func (s *Panic) String() string { // Be robust against malformed CFG. block := -1 if s.block != nil && len(s.block.Succs) == 1 { block = s.block.Succs[0].Index } return fmt.Sprintf("Panic %s → b%d", relName(s.X, s), block) } func (s *Return) String() string { var b bytes.Buffer b.WriteString("Return") for _, r := range s.Results { b.WriteString(" ") b.WriteString(relName(r, s)) } return b.String() } func (*RunDefers) String() string { return "RunDefers" } func (s *Send) String() string { return fmt.Sprintf("Send %s %s", relName(s.Chan, s), relName(s.X, s)) } func (recv *Recv) String() string { from := recv.Parent().pkg() return fmt.Sprintf("Recv <%s> %s", relType(recv.Type(), from), relName(recv.Chan, recv)) } func (s *Defer) String() string { prefix := "Defer " if s._DeferStack != nil { prefix += "[" + relName(s._DeferStack, s) + "] " } c := printCall(&s.Call, prefix, s) return c } func (s *Select) String() string { var b bytes.Buffer for i, st := range s.States { if i > 0 { b.WriteString(", ") } if st.Dir == types.RecvOnly { b.WriteString("<-") b.WriteString(relName(st.Chan, s)) } else { b.WriteString(relName(st.Chan, s)) b.WriteString("<-") b.WriteString(relName(st.Send, s)) } } non := "" if !s.Blocking { non = "Non" } from := s.Parent().pkg() return fmt.Sprintf("Select%sBlocking <%s> [%s]", non, relType(s.Type(), from), b.String()) } func (s *Store) String() string { return fmt.Sprintf("Store {%s} %s %s", s.Val.Type(), relName(s.Addr, s), relName(s.Val, s)) } func (s *BlankStore) String() string { return fmt.Sprintf("BlankStore %s", relName(s.Val, s)) } func (s *MapUpdate) String() string { return fmt.Sprintf("MapUpdate %s %s %s", relName(s.Map, s), relName(s.Key, s), relName(s.Value, s)) } func (s *DebugRef) String() string { p := s.Parent().Prog.Fset.Position(s.Pos()) var descr interface{} if s.object != nil { descr = s.object // e.g. "var x int" } else { descr = reflect.TypeOf(s.Expr) // e.g. "*ast.CallExpr" } var addr string if s.IsAddr { addr = "address of " } return fmt.Sprintf("; %s%s @ %d:%d is %s", addr, descr, p.Line, p.Column, s.X.Name()) } func (p *Package) String() string { return "package " + p.Pkg.Path() } var _ io.WriterTo = (*Package)(nil) // *Package implements io.Writer func (p *Package) WriteTo(w io.Writer) (int64, error) { var buf bytes.Buffer WritePackage(&buf, p) n, err := w.Write(buf.Bytes()) return int64(n), err } // WritePackage writes to buf a human-readable summary of p. func WritePackage(buf *bytes.Buffer, p *Package) { fmt.Fprintf(buf, "%s:\n", p) var names []string maxname := 0 for name := range p.Members { if l := len(name); l > maxname { maxname = l } names = append(names, name) } from := p.Pkg sort.Strings(names) for _, name := range names { switch mem := p.Members[name].(type) { case *NamedConst: fmt.Fprintf(buf, " const %-*s %s = %s\n", maxname, name, mem.Name(), mem.Value.RelString(from)) case *Function: fmt.Fprintf(buf, " func %-*s %s\n", maxname, name, relType(mem.Type(), from)) case *Type: fmt.Fprintf(buf, " type %-*s %s\n", maxname, name, relType(mem.Type().Underlying(), from)) for _, meth := range typeutil.IntuitiveMethodSet(mem.Type(), &p.Prog.MethodSets) { fmt.Fprintf(buf, " %s\n", types.SelectionString(meth, types.RelativeTo(from))) } case *Global: fmt.Fprintf(buf, " var %-*s %s\n", maxname, name, relType(mem.Type().(*types.Pointer).Elem(), from)) } } fmt.Fprintf(buf, "\n") } func (v *MultiConvert) String() string { from := v.Parent().Pkg.Pkg var b strings.Builder b.WriteString(printConv("MultiConvert", v, v.X)) b.WriteString(" [") for i, s := range v.from.Terms { for j, d := range v.to.Terms { if i != 0 || j != 0 { b.WriteString(" | ") } fmt.Fprintf(&b, "%s -> %s", relTerm(s, from), relTerm(d, from)) } } b.WriteString("]") return b.String() } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/sanity.go�������������������������������������������������������0000664�0000000�0000000�00000036336�14657040722�0020764�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright 2013 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. package ir // An optional pass for sanity-checking invariants of the IR representation. // Currently it checks CFG invariants but little at the instruction level. import ( "bytes" "fmt" "go/ast" "go/types" "io" "os" "strings" "honnef.co/go/tools/go/types/typeutil" ) type sanity struct { reporter io.Writer fn *Function block *BasicBlock instrs map[Instruction]struct{} insane bool } // sanityCheck performs integrity checking of the IR representation // of the function fn and returns true if it was valid. Diagnostics // are written to reporter if non-nil, os.Stderr otherwise. Some // diagnostics are only warnings and do not imply a negative result. // // Sanity-checking is intended to facilitate the debugging of code // transformation passes. func sanityCheck(fn *Function, reporter io.Writer) bool { if reporter == nil { reporter = os.Stderr } return (&sanity{reporter: reporter}).checkFunction(fn) } // mustSanityCheck is like sanityCheck but panics instead of returning // a negative result. func mustSanityCheck(fn *Function, reporter io.Writer) { if !sanityCheck(fn, reporter) { fn.WriteTo(os.Stderr) panic("SanityCheck failed") } } func (s *sanity) diagnostic(prefix, format string, args ...interface{}) { fmt.Fprintf(s.reporter, "%s: function %s", prefix, s.fn) if s.block != nil { fmt.Fprintf(s.reporter, ", block %s", s.block) } io.WriteString(s.reporter, ": ") fmt.Fprintf(s.reporter, format, args...) io.WriteString(s.reporter, "\n") } func (s *sanity) errorf(format string, args ...interface{}) { s.insane = true s.diagnostic("Error", format, args...) } func (s *sanity) warnf(format string, args ...interface{}) { s.diagnostic("Warning", format, args...) } // findDuplicate returns an arbitrary basic block that appeared more // than once in blocks, or nil if all were unique. func findDuplicate(blocks []*BasicBlock) *BasicBlock { if len(blocks) < 2 { return nil } if blocks[0] == blocks[1] { return blocks[0] } // Slow path: m := make(map[*BasicBlock]bool) for _, b := range blocks { if m[b] { return b } m[b] = true } return nil } func (s *sanity) checkInstr(idx int, instr Instruction) { switch instr := instr.(type) { case *If, *Jump, *Return, *Panic, *Unreachable, *ConstantSwitch: s.errorf("control flow instruction not at end of block") case *Sigma: if idx > 0 { prev := s.block.Instrs[idx-1] if _, ok := prev.(*Sigma); !ok { s.errorf("Sigma instruction follows a non-Sigma: %T", prev) } } case *Phi: if idx == 0 { // It suffices to apply this check to just the first phi node. if dup := findDuplicate(s.block.Preds); dup != nil { s.errorf("phi node in block with duplicate predecessor %s", dup) } } else { prev := s.block.Instrs[idx-1] switch prev.(type) { case *Phi, *Sigma: default: s.errorf("Phi instruction follows a non-Phi, non-Sigma: %T", prev) } } if ne, np := len(instr.Edges), len(s.block.Preds); ne != np { s.errorf("phi node has %d edges but %d predecessors", ne, np) } else { for i, e := range instr.Edges { if e == nil { s.errorf("phi node '%s' has no value for edge #%d from %s", instr.Comment(), i, s.block.Preds[i]) } } } case *Alloc: if !instr.Heap { found := false for _, l := range s.fn.Locals { if l == instr { found = true break } } if !found { s.errorf("local alloc %s = %s does not appear in Function.Locals", instr.Name(), instr) } } case *BinOp: case *Call: case *ChangeInterface: case *ChangeType: case *SliceToArrayPointer: case *SliceToArray: case *Convert: tsetInstrX := typeutil.NewTypeSet(instr.X.Type().Underlying()) tsetInstr := typeutil.NewTypeSet(instr.Type().Underlying()) ok1 := tsetInstr.Any(func(term *types.Term) bool { _, ok := term.Type().Underlying().(*types.Basic); return ok }) ok2 := tsetInstrX.Any(func(term *types.Term) bool { _, ok := term.Type().Underlying().(*types.Basic); return ok }) if !ok1 && !ok2 { s.errorf("convert %s -> %s: at least one type set must contain basic type", instr.X.Type(), instr.Type()) } case *MultiConvert: case *Defer: case *Extract: case *Field: case *FieldAddr: case *Go: case *Index: case *IndexAddr: case *MapLookup: case *StringLookup: case *MakeChan: case *MakeClosure: numFree := len(instr.Fn.(*Function).FreeVars) numBind := len(instr.Bindings) if numFree != numBind { s.errorf("MakeClosure has %d Bindings for function %s with %d free vars", numBind, instr.Fn, numFree) } if recv := instr.Type().(*types.Signature).Recv(); recv != nil { s.errorf("MakeClosure's type includes receiver %s", recv.Type()) } case *MakeInterface: case *MakeMap: case *MakeSlice: case *MapUpdate: case *Next: case *Range: case *RunDefers: case *Select: case *Send: case *Slice: case *Store: case *TypeAssert: case *UnOp: case *DebugRef: case *BlankStore: case *Load: case *Parameter: case *Const: case *AggregateConst: case *ArrayConst: case *GenericConst: case *Recv: case *TypeSwitch: case *CompositeValue: default: panic(fmt.Sprintf("Unknown instruction type: %T", instr)) } if call, ok := instr.(CallInstruction); ok { if call.Common().Signature() == nil { s.errorf("nil signature: %s", call) } } // Check that value-defining instructions have valid types // and a valid referrer list. if v, ok := instr.(Value); ok { t := v.Type() if t == nil { s.errorf("no type: %s = %s", v.Name(), v) } else if b, ok := t.Underlying().(*types.Basic); ok && b.Info()&types.IsUntyped != 0 { if _, ok := v.(*Const); !ok { s.errorf("instruction has 'untyped' result: %s = %s : %s", v.Name(), v, t) } } s.checkReferrerList(v) } // Untyped constants are legal as instruction Operands(), // for example: // _ = "foo"[0] // or: // if wordsize==64 {...} // All other non-Instruction Values can be found via their // enclosing Function or Package. } func (s *sanity) checkFinalInstr(instr Instruction) { switch instr := instr.(type) { case *If: if nsuccs := len(s.block.Succs); nsuccs != 2 { s.errorf("If-terminated block has %d successors; expected 2", nsuccs) return } if s.block.Succs[0] == s.block.Succs[1] { s.errorf("If-instruction has same True, False target blocks: %s", s.block.Succs[0]) return } case *Jump: if nsuccs := len(s.block.Succs); nsuccs != 1 { s.errorf("Jump-terminated block has %d successors; expected 1", nsuccs) return } case *Return: if nsuccs := len(s.block.Succs); nsuccs != 0 { s.errorf("Return-terminated block has %d successors; expected none", nsuccs) return } if na, nf := len(instr.Results), s.fn.Signature.Results().Len(); nf != na { s.errorf("%d-ary return in %d-ary function", na, nf) } case *Panic: if nsuccs := len(s.block.Succs); nsuccs != 1 { s.errorf("Panic-terminated block has %d successors; expected one", nsuccs) return } case *Unreachable: if nsuccs := len(s.block.Succs); nsuccs != 1 { s.errorf("Unreachable-terminated block has %d successors; expected one", nsuccs) return } case *ConstantSwitch: default: s.errorf("non-control flow instruction at end of block") } } func (s *sanity) checkBlock(b *BasicBlock, index int) { s.block = b if b.Index != index { s.errorf("block has incorrect Index %d", b.Index) } if b.parent != s.fn { s.errorf("block has incorrect parent %s", b.parent) } // Check all blocks are reachable. // (The entry block is always implicitly reachable, the exit block may be unreachable.) if index > 1 && len(b.Preds) == 0 { s.warnf("unreachable block") if b.Instrs == nil { // Since this block is about to be pruned, // tolerating transient problems in it // simplifies other optimizations. return } } // Check predecessor and successor relations are dual, // and that all blocks in CFG belong to same function. for _, a := range b.Preds { found := false for _, bb := range a.Succs { if bb == b { found = true break } } if !found { s.errorf("expected successor edge in predecessor %s; found only: %s", a, a.Succs) } if a.parent != s.fn { s.errorf("predecessor %s belongs to different function %s", a, a.parent) } } for _, c := range b.Succs { found := false for _, bb := range c.Preds { if bb == b { found = true break } } if !found { s.errorf("expected predecessor edge in successor %s; found only: %s", c, c.Preds) } if c.parent != s.fn { s.errorf("successor %s belongs to different function %s", c, c.parent) } } // Check each instruction is sane. n := len(b.Instrs) if n == 0 { s.errorf("basic block contains no instructions") } var rands [10]*Value // reuse storage for j, instr := range b.Instrs { if instr == nil { s.errorf("nil instruction at index %d", j) continue } if b2 := instr.Block(); b2 == nil { s.errorf("nil Block() for instruction at index %d", j) continue } else if b2 != b { s.errorf("wrong Block() (%s) for instruction at index %d ", b2, j) continue } if j < n-1 { s.checkInstr(j, instr) } else { s.checkFinalInstr(instr) } // Check Instruction.Operands. operands: for i, op := range instr.Operands(rands[:0]) { if op == nil { s.errorf("nil operand pointer %d of %s", i, instr) continue } val := *op if val == nil { continue // a nil operand is ok } // Check that "untyped" types only appear on constant operands. if _, ok := (*op).(*Const); !ok { if basic, ok := types.Unalias((*op).Type()).(*types.Basic); ok { if basic.Info()&types.IsUntyped != 0 { s.errorf("operand #%d of %s is untyped: %s", i, instr, basic) } } } // Check that Operands that are also Instructions belong to same function. // TODO(adonovan): also check their block dominates block b. if val, ok := val.(Instruction); ok { if val.Block() == nil { s.errorf("operand %d of %s is an instruction (%s) that belongs to no block", i, instr, val) } else if val.Parent() != s.fn { s.errorf("operand %d of %s is an instruction (%s) from function %s", i, instr, val, val.Parent()) } } // Check that each function-local operand of // instr refers back to instr. (NB: quadratic) switch val := val.(type) { case *Const, *Global, *Builtin: continue // not local case *Function: if val.parent == nil { continue // only anon functions are local } } // TODO(adonovan): check val.Parent() != nil <=> val.Referrers() is defined. if refs := val.Referrers(); refs != nil { for _, ref := range *refs { if ref == instr { continue operands } } s.errorf("operand %d of %s (%s) does not refer to us", i, instr, val) } else { s.errorf("operand %d of %s (%s) has no referrers", i, instr, val) } } } } func (s *sanity) checkReferrerList(v Value) { refs := v.Referrers() if refs == nil { s.errorf("%s has missing referrer list", v.Name()) return } for i, ref := range *refs { if _, ok := s.instrs[ref]; !ok { if val, ok := ref.(Value); ok { s.errorf("%s.Referrers()[%d] = %s = %s is not an instruction belonging to this function", v.Name(), i, val.Name(), val) } else { s.errorf("%s.Referrers()[%d] = %s is not an instruction belonging to this function", v.Name(), i, ref) } } } } func (s *sanity) checkFunction(fn *Function) bool { // TODO(adonovan): check Function invariants: // - check params match signature // - check transient fields are nil // - warn if any fn.Locals do not appear among block instructions. s.fn = fn if fn.Prog == nil { s.errorf("nil Prog") } var buf bytes.Buffer _ = fn.String() // must not crash _ = fn.RelString(fn.pkg()) // must not crash WriteFunction(&buf, fn) // must not crash // All functions have a package, except delegates (which are // shared across packages, or duplicated as weak symbols in a // separate-compilation model), and error.Error. if fn.Pkg == nil { switch fn.Synthetic { case SyntheticWrapper, SyntheticBound, SyntheticThunk, SyntheticGeneric: default: if !strings.HasSuffix(fn.name, "Error") { s.errorf("nil Pkg") } } } if syn, src := fn.Synthetic == 0, fn.source != nil; src != syn { if _, ok := fn.source.(*ast.RangeStmt); !ok || fn.Synthetic != SyntheticRangeOverFuncYield { // Only range-over-func yield functions are synthetic and have syntax s.errorf("got fromSource=%t, hasSyntax=%t; want same values", src, syn) } } for i, l := range fn.Locals { if l.Parent() != fn { s.errorf("Local %s at index %d has wrong parent", l.Name(), i) } if l.Heap { s.errorf("Local %s at index %d has Heap flag set", l.Name(), i) } } // Build the set of valid referrers. s.instrs = make(map[Instruction]struct{}) for _, b := range fn.Blocks { for _, instr := range b.Instrs { s.instrs[instr] = struct{}{} } } for i, p := range fn.Params { if p.Parent() != fn { s.errorf("Param %s at index %d has wrong parent", p.Name(), i) } // Check common suffix of Signature and Params match type. if sig := fn.Signature; sig != nil { j := i - len(fn.Params) + sig.Params().Len() // index within sig.Params if j < 0 { continue } if !types.Identical(p.Type(), sig.Params().At(j).Type()) { s.errorf("Param %s at index %d has wrong type (%s, versus %s in Signature)", p.Name(), i, p.Type(), sig.Params().At(j).Type()) } } s.checkReferrerList(p) } for i, fv := range fn.FreeVars { if fv.Parent() != fn { s.errorf("FreeVar %s at index %d has wrong parent", fv.Name(), i) } s.checkReferrerList(fv) } if fn.Blocks != nil && len(fn.Blocks) == 0 { // Function _had_ blocks (so it's not external) but // they were "optimized" away, even the entry block. s.errorf("Blocks slice is non-nil but empty") } for i, b := range fn.Blocks { if b == nil { s.warnf("nil *BasicBlock at f.Blocks[%d]", i) continue } s.checkBlock(b, i) } s.block = nil for i, anon := range fn.AnonFuncs { if anon.Parent() != fn { s.errorf("AnonFuncs[%d]=%s but %s.Parent()=%s", i, anon, anon, anon.Parent()) } } s.fn = nil return !s.insane } // sanityCheckPackage checks invariants of packages upon creation. // It does not require that the package is built. // Unlike sanityCheck (for functions), it just panics at the first error. func sanityCheckPackage(pkg *Package) { if pkg.Pkg == nil { panic(fmt.Sprintf("Package %s has no Object", pkg)) } _ = pkg.String() // must not crash for name, mem := range pkg.Members { if name != mem.Name() { panic(fmt.Sprintf("%s: %T.Name() = %s, want %s", pkg.Pkg.Path(), mem, mem.Name(), name)) } obj := mem.Object() if obj == nil { // This check is sound because fields // {Global,Function}.object have type // types.Object. (If they were declared as // *types.{Var,Func}, we'd have a non-empty // interface containing a nil pointer.) continue // not all members have typechecker objects } if obj.Name() != name { if obj.Name() == "init" && strings.HasPrefix(mem.Name(), "init#") { // Ok. The name of a declared init function varies between // its types.Func ("init") and its ir.Function ("init#%d"). } else { panic(fmt.Sprintf("%s: %T.Object().Name() = %s, want %s", pkg.Pkg.Path(), mem, obj.Name(), name)) } } } } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/source.go�������������������������������������������������������0000664�0000000�0000000�00000020625�14657040722�0020747�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright 2013 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. package ir // This file defines utilities for working with source positions // or source-level named entities ("objects"). // TODO(adonovan): test that {Value,Instruction}.Pos() positions match // the originating syntax, as specified. import ( "go/ast" "go/token" "go/types" ) // EnclosingFunction returns the function that contains the syntax // node denoted by path. // // Syntax associated with package-level variable specifications is // enclosed by the package's init() function. // // Returns nil if not found; reasons might include: // - the node is not enclosed by any function. // - the node is within an anonymous function (FuncLit) and // its IR function has not been created yet // (pkg.Build() has not yet been called). func EnclosingFunction(pkg *Package, path []ast.Node) *Function { // Start with package-level function... fn := findEnclosingPackageLevelFunction(pkg, path) if fn == nil { return nil // not in any function } // ...then walk down the nested anonymous functions. n := len(path) outer: for i := range path { if lit, ok := path[n-1-i].(*ast.FuncLit); ok { for _, anon := range fn.AnonFuncs { if anon.Pos() == lit.Type.Func { fn = anon continue outer } } // IR function not found: // - package not yet built, or maybe // - builder skipped FuncLit in dead block // (in principle; but currently the Builder // generates even dead FuncLits). return nil } } return fn } // HasEnclosingFunction returns true if the AST node denoted by path // is contained within the declaration of some function or // package-level variable. // // Unlike EnclosingFunction, the behaviour of this function does not // depend on whether IR code for pkg has been built, so it can be // used to quickly reject check inputs that will cause // EnclosingFunction to fail, prior to IR building. func HasEnclosingFunction(pkg *Package, path []ast.Node) bool { return findEnclosingPackageLevelFunction(pkg, path) != nil } // findEnclosingPackageLevelFunction returns the Function // corresponding to the package-level function enclosing path. func findEnclosingPackageLevelFunction(pkg *Package, path []ast.Node) *Function { if n := len(path); n >= 2 { // [... {Gen,Func}Decl File] switch decl := path[n-2].(type) { case *ast.GenDecl: if decl.Tok == token.VAR && n >= 3 { // Package-level 'var' initializer. return pkg.init } case *ast.FuncDecl: // Declared function/method. fn := findNamedFunc(pkg, decl.Pos()) if fn == nil && decl.Recv == nil && decl.Name.Name == "init" { // Hack: return non-nil when IR is not yet // built so that HasEnclosingFunction works. return pkg.init } return fn } } return nil // not in any function } // findNamedFunc returns the named function whose FuncDecl.Ident is at // position pos. func findNamedFunc(pkg *Package, pos token.Pos) *Function { for _, fn := range pkg.Functions { if fn.Pos() == pos { return fn } } return nil } // ValueForExpr returns the IR Value that corresponds to non-constant // expression e. // // It returns nil if no value was found, e.g. // - the expression is not lexically contained within f; // - f was not built with debug information; or // - e is a constant expression. (For efficiency, no debug // information is stored for constants. Use // go/types.Info.Types[e].Value instead.) // - e is a reference to nil or a built-in function. // - the value was optimised away. // // If e is an addressable expression used in an lvalue context, // value is the address denoted by e, and isAddr is true. // // The types of e (or &e, if isAddr) and the result are equal // (modulo "untyped" bools resulting from comparisons). // // (Tip: to find the ir.Value given a source position, use // astutil.PathEnclosingInterval to locate the ast.Node, then // EnclosingFunction to locate the Function, then ValueForExpr to find // the ir.Value.) func (f *Function) ValueForExpr(e ast.Expr) (value Value, isAddr bool) { if f.debugInfo() { // (opt) e = unparen(e) for _, b := range f.Blocks { for _, instr := range b.Instrs { if ref, ok := instr.(*DebugRef); ok { if ref.Expr == e { return ref.X, ref.IsAddr } } } } } return } // --- Lookup functions for source-level named entities (types.Objects) --- // Package returns the IR Package corresponding to the specified // type-checker package object. // It returns nil if no such IR package has been created. func (prog *Program) Package(obj *types.Package) *Package { return prog.packages[obj] } // packageLevelValue returns the package-level value corresponding to // the specified named object, which may be a package-level const // (*Const), var (*Global) or func (*Function) of some package in // prog. It returns nil if the object is not found. func (prog *Program) packageLevelValue(obj types.Object) Value { if pkg, ok := prog.packages[obj.Pkg()]; ok { return pkg.values[obj] } return nil } // FuncValue returns the concrete Function denoted by the source-level // named function obj, or nil if obj denotes an interface method. // // TODO(adonovan): check the invariant that obj.Type() matches the // result's Signature, both in the params/results and in the receiver. func (prog *Program) FuncValue(obj *types.Func) *Function { obj = obj.Origin() fn, _ := prog.packageLevelValue(obj).(*Function) return fn } // ConstValue returns the IR Value denoted by the source-level named // constant obj. func (prog *Program) ConstValue(obj *types.Const) *Const { // TODO(adonovan): opt: share (don't reallocate) // Consts for const objects and constant ast.Exprs. // Universal constant? {true,false,nil} if obj.Parent() == types.Universe { return NewConst(obj.Val(), obj.Type(), nil) } // Package-level named constant? if v := prog.packageLevelValue(obj); v != nil { return v.(*Const) } return NewConst(obj.Val(), obj.Type(), nil) } // VarValue returns the IR Value that corresponds to a specific // identifier denoting the source-level named variable obj. // // VarValue returns nil if a local variable was not found, perhaps // because its package was not built, the debug information was not // requested during IR construction, or the value was optimized away. // // ref is the path to an ast.Ident (e.g. from PathEnclosingInterval), // and that ident must resolve to obj. // // pkg is the package enclosing the reference. (A reference to a var // always occurs within a function, so we need to know where to find it.) // // If the identifier is a field selector and its base expression is // non-addressable, then VarValue returns the value of that field. // For example: // // func f() struct {x int} // f().x // VarValue(x) returns a *Field instruction of type int // // All other identifiers denote addressable locations (variables). // For them, VarValue may return either the variable's address or its // value, even when the expression is evaluated only for its value; the // situation is reported by isAddr, the second component of the result. // // If !isAddr, the returned value is the one associated with the // specific identifier. For example, // // var x int // VarValue(x) returns Const 0 here // x = 1 // VarValue(x) returns Const 1 here // // It is not specified whether the value or the address is returned in // any particular case, as it may depend upon optimizations performed // during IR code generation, such as registerization, constant // folding, avoidance of materialization of subexpressions, etc. func (prog *Program) VarValue(obj *types.Var, pkg *Package, ref []ast.Node) (value Value, isAddr bool) { // All references to a var are local to some function, possibly init. fn := EnclosingFunction(pkg, ref) if fn == nil { return // e.g. def of struct field; IR not built? } id := ref[0].(*ast.Ident) // Defining ident of a parameter? if id.Pos() == obj.Pos() { for _, param := range fn.Params { if param.Object() == obj { return param, false } } } // Other ident? for _, b := range fn.Blocks { for _, instr := range b.Instrs { if dr, ok := instr.(*DebugRef); ok { if dr.Pos() == id.Pos() { return dr.X, dr.IsAddr } } } } // Defining ident of package-level var? if v := prog.packageLevelValue(obj); v != nil { return v.(*Global), true } return // e.g. debug info not requested, or var optimized away } �����������������������������������������������������������������������������������������������������������golang-honnef-go-tools-2024.1/go/ir/source_test.go��������������������������������������������������0000664�0000000�0000000�00000026305�14657040722�0022007�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright 2013 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. //lint:file-ignore SA1019 go/ssa's test suite is built around the deprecated go/loader. We'll leave fixing that to upstream. package ir_test // This file defines tests of source-level debugging utilities. import ( "fmt" "go/ast" "go/constant" "go/parser" "go/token" "go/types" "io/ioutil" "os" "path/filepath" "runtime" "strings" "testing" "honnef.co/go/tools/go/ast/astutil" "honnef.co/go/tools/go/ir" "honnef.co/go/tools/go/ir/irutil" "golang.org/x/tools/go/analysis/analysistest" "golang.org/x/tools/go/expect" "golang.org/x/tools/go/loader" ) func TestObjValueLookup(t *testing.T) { if runtime.GOOS == "android" { t.Skipf("no testdata directory on %s", runtime.GOOS) } conf := loader.Config{ParserMode: parser.ParseComments} src, err := ioutil.ReadFile(filepath.Join(analysistest.TestData(), "objlookup.go")) if err != nil { t.Fatal(err) } readFile := func(filename string) ([]byte, error) { return src, nil } f, err := conf.ParseFile(filepath.Join(analysistest.TestData(), "objlookup.go"), src) if err != nil { t.Fatal(err) } conf.CreateFromFiles("main", f) // Maps each var Ident (represented "name:linenum") to the // kind of ir.Value we expect (represented "Constant", "&Alloc"). expectations := make(map[string]string) // Each note of the form @ir(x, "BinOp") in testdata/objlookup.go // specifies an expectation that an object named x declared on the // same line is associated with an an ir.Value of type *ir.BinOp. notes, err := expect.ExtractGo(conf.Fset, f) if err != nil { t.Fatal(err) } for _, n := range notes { if n.Name != "ir" { t.Errorf("%v: unexpected note type %q, want \"ir\"", conf.Fset.Position(n.Pos), n.Name) continue } if len(n.Args) != 2 { t.Errorf("%v: ir has %d args, want 2", conf.Fset.Position(n.Pos), len(n.Args)) continue } ident, ok := n.Args[0].(expect.Identifier) if !ok { t.Errorf("%v: got %v for arg 1, want identifier", conf.Fset.Position(n.Pos), n.Args[0]) continue } exp, ok := n.Args[1].(string) if !ok { t.Errorf("%v: got %v for arg 2, want string", conf.Fset.Position(n.Pos), n.Args[1]) continue } p, _, err := expect.MatchBefore(conf.Fset, readFile, n.Pos, string(ident)) if err != nil { t.Error(err) continue } pos := conf.Fset.Position(p) key := fmt.Sprintf("%s:%d", ident, pos.Line) expectations[key] = exp } iprog, err := conf.Load() if err != nil { t.Error(err) return } prog := irutil.CreateProgram(iprog, 0 /*|ir.PrintFunctions*/) mainInfo := iprog.Created[0] mainPkg := prog.Package(mainInfo.Pkg) mainPkg.SetDebugMode(true) mainPkg.Build() var varIds []*ast.Ident var varObjs []*types.Var for id, obj := range mainInfo.Defs { // Check invariants for func and const objects. switch obj := obj.(type) { case *types.Func: checkFuncValue(t, prog, obj) case *types.Const: checkConstValue(t, prog, obj) case *types.Var: if id.Name == "_" { continue } varIds = append(varIds, id) varObjs = append(varObjs, obj) } } for id, obj := range mainInfo.Uses { if obj, ok := obj.(*types.Var); ok { varIds = append(varIds, id) varObjs = append(varObjs, obj) } } // Check invariants for var objects. // The result varies based on the specific Ident. for i, id := range varIds { obj := varObjs[i] ref, _ := astutil.PathEnclosingInterval(f, id.Pos(), id.Pos()) pos := prog.Fset.Position(id.Pos()) exp := expectations[fmt.Sprintf("%s:%d", id.Name, pos.Line)] if exp == "" { t.Errorf("%s: no expectation for var ident %s ", pos, id.Name) continue } wantAddr := false if exp[0] == '&' { wantAddr = true exp = exp[1:] } checkVarValue(t, prog, mainPkg, ref, obj, exp, wantAddr) } } func checkFuncValue(t *testing.T, prog *ir.Program, obj *types.Func) { fn := prog.FuncValue(obj) // fmt.Printf("FuncValue(%s) = %s\n", obj, fn) // debugging if fn == nil { if obj.Name() != "interfaceMethod" { t.Errorf("FuncValue(%s) == nil", obj) } return } if fnobj := fn.Object(); fnobj != obj { t.Errorf("FuncValue(%s).Object() == %s; value was %s", obj, fnobj, fn.Name()) return } if !types.Identical(fn.Type(), obj.Type()) { t.Errorf("FuncValue(%s).Type() == %s", obj, fn.Type()) return } } func checkConstValue(t *testing.T, prog *ir.Program, obj *types.Const) { c := prog.ConstValue(obj) // fmt.Printf("ConstValue(%s) = %s\n", obj, c) // debugging if c == nil { t.Errorf("ConstValue(%s) == nil", obj) return } if !types.Identical(c.Type(), obj.Type()) { t.Errorf("ConstValue(%s).Type() == %s", obj, c.Type()) return } if obj.Name() != "nil" { if !constant.Compare(c.Value, token.EQL, obj.Val()) { t.Errorf("ConstValue(%s).Value (%s) != %s", obj, c.Value, obj.Val()) return } } } func checkVarValue(t *testing.T, prog *ir.Program, pkg *ir.Package, ref []ast.Node, obj *types.Var, expKind string, wantAddr bool) { // The prefix of all assertions messages. prefix := fmt.Sprintf("VarValue(%s @ L%d)", obj, prog.Fset.Position(ref[0].Pos()).Line) v, gotAddr := prog.VarValue(obj, pkg, ref) // Kind is the concrete type of the ir Value. gotKind := "nil" if v != nil { gotKind = fmt.Sprintf("%T", v)[len("*ir."):] } // fmt.Printf("%s = %v (kind %q; expect %q) wantAddr=%t gotAddr=%t\n", prefix, v, gotKind, expKind, wantAddr, gotAddr) // debugging // Check the kinds match. // "nil" indicates expected failure (e.g. optimized away). if expKind != gotKind { t.Errorf("%s concrete type == %s, want %s", prefix, gotKind, expKind) } // Check the types match. // If wantAddr, the expected type is the object's address. if v != nil { expType := obj.Type() if wantAddr { expType = types.NewPointer(expType) if !gotAddr { t.Errorf("%s: got value, want address", prefix) } } else if gotAddr { t.Errorf("%s: got address, want value", prefix) } if !types.Identical(v.Type(), expType) { t.Errorf("%s.Type() == %s, want %s", prefix, v.Type(), expType) } } } // Ensure that, in debug mode, we can determine the ir.Value // corresponding to every ast.Expr. func TestValueForExpr(t *testing.T) { testValueForExpr(t, filepath.Join(analysistest.TestData(), "valueforexpr.go")) } func testValueForExpr(t *testing.T, testfile string) { if runtime.GOOS == "android" { t.Skipf("no testdata dir on %s", runtime.GOOS) } conf := loader.Config{ParserMode: parser.ParseComments} f, err := conf.ParseFile(testfile, nil) if err != nil { t.Error(err) return } conf.CreateFromFiles("main", f) iprog, err := conf.Load() if err != nil { t.Error(err) return } mainInfo := iprog.Created[0] prog := irutil.CreateProgram(iprog, 0) mainPkg := prog.Package(mainInfo.Pkg) mainPkg.SetDebugMode(true) mainPkg.Build() if false { // debugging for _, mem := range mainPkg.Members { if fn, ok := mem.(*ir.Function); ok { fn.WriteTo(os.Stderr) } } } var parenExprs []*ast.ParenExpr ast.Inspect(f, func(n ast.Node) bool { if n != nil { if e, ok := n.(*ast.ParenExpr); ok { parenExprs = append(parenExprs, e) } } return true }) notes, err := expect.ExtractGo(prog.Fset, f) if err != nil { t.Fatal(err) } for _, n := range notes { want := n.Name if want == "nil" { want = "" } position := prog.Fset.Position(n.Pos) var e ast.Expr for _, paren := range parenExprs { if paren.Pos() > n.Pos { e = paren.X break } } if e == nil { t.Errorf("%s: note doesn't precede ParenExpr: %q", position, want) continue } path, _ := astutil.PathEnclosingInterval(f, n.Pos, n.Pos) if path == nil { t.Errorf("%s: can't find AST path from root to comment: %s", position, want) continue } fn := ir.EnclosingFunction(mainPkg, path) if fn == nil { t.Errorf("%s: can't find enclosing function", position) continue } v, gotAddr := fn.ValueForExpr(e) // (may be nil) got := strings.TrimPrefix(fmt.Sprintf("%T", v), "*ir.") if got != want { t.Errorf("%s: got value %q, want %q", position, got, want) } if v != nil { T := v.Type() if gotAddr { T = T.Underlying().(*types.Pointer).Elem() // deref } if !types.Identical(T, mainInfo.TypeOf(e)) { t.Errorf("%s: got type %s, want %s", position, mainInfo.TypeOf(e), T) } } } } // findInterval parses input and returns the [start, end) positions of // the first occurrence of substr in input. f==nil indicates failure; // an error has already been reported in that case. func findInterval(t *testing.T, fset *token.FileSet, input, substr string) (f *ast.File, start, end token.Pos) { f, err := parser.ParseFile(fset, "" url = 'https://github.com/dominikh/go-tools' weight = 999 [markup] [markup.highlight] style = "tango" [params] description = 'Staticcheck is a state of the art linter for the Go programming language' images = ['/img/logo.webp'] title = 'Staticcheck' golang-honnef-go-tools-2024.1/website/content/000077500000000000000000000000001465704072200212105ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/content/_index.md000066400000000000000000000045541465704072200230100ustar00rootroot00000000000000--- title: Staticcheck --- {{< blocks/lead type="section" color="primary" >}} Our mascot, the engineer Staticcheck is a state of the art linter for the Go programming language. Using static analysis, it finds bugs and performance issues, offers simplifications, and enforces style rules.
    }}"> Get started
    {{< /blocks/lead >}} {{< blocks/section color="white" >}} {{% blocks/feature title="Correctness" icon="fa-check" %}} Code obviously has to be correct. Unfortunately, it never is. Some code is more correct than other, but there'll always be bugs. Tests catch some, your peers catch others, and Staticcheck catches some more. {{% /blocks/feature %}} {{% blocks/feature title="Simplicity" icon="fa-circle" %}} After correctness comes simplicity. There are many ways to skin a cat (but please don't), but some are unnecessarily elaborate. Staticcheck helps you replace complex code with simple code. {{% /blocks/feature %}} {{% blocks/feature title="Maintainability" icon="fa-screwdriver" %}} Code is a living thing. If it's not maintained regularly, it will become stale and unreliable. It won't catch up when its dependencies move on or guidelines change. Staticcheck is like a sitter for your code for when you don't have time. {{% /blocks/feature %}} {{% blocks/feature title="Exhaustiveness" icon="fas fa-tasks" url="/docs/checks" %}} More than {{< numchecks.inline >}} {{- $c := len $.Site.Data.checks.Checks -}} {{- sub $c (mod $c 25) -}} {{< /numchecks.inline >}} checks ensure that your code is in tip-top shape. {{% /blocks/feature %}} {{% blocks/feature title="Integration" icon="fab fa-github" %}} Staticcheck can easily be integrated with your code review and CI systems, preventing buggy code from ever getting committed. {{% /blocks/feature %}} {{% blocks/feature title="Editor integration" icon="fa-i-cursor" url="https://github.com/golang/tools/blob/master/gopls/doc/settings.md#staticcheck-bool" %}} Staticcheck is part of most major Go editors and has been integrated with gopls, finding bugs and offering automatic fixes. {{% /blocks/feature %}} {{< /blocks/section >}} golang-honnef-go-tools-2024.1/website/content/changes/000077500000000000000000000000001465704072200226205ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/content/changes/2017.2.md000066400000000000000000000116061465704072200236770ustar00rootroot00000000000000--- title: Staticcheck 2017.2 release notes linkTitle: 2017.2 weight: -1 --- The 2017.2 release of the staticcheck suite of tools focuses on reducing friction – fewer false positives, more tools for suppressing unwanted output, and JSON output for easier integration with other tools. ## New features ### Linter directives for ignoring problems In the past, the only ways to ignore reported problems was by using the `-ignore` flag. This led to overreaching ignore rules which weren't maintained regularly. Now, `//lint:ignore` and `//lint:file-ignore` comments can be used to ignore problems, either on specific lines or file-wide. A full description of these directives, their syntax and their behavior can be found in [the documentation]({{< relref "/docs/configuration#ignoring-problems" >}}). A related change adds the `-show-ignored` command line flag, which outputs problems that would otherwise be ignored by directives. This is primarily of use with the JSON output format, for custom front ends. ### Output formats All staticcheck tools now support multiple output formats, selectable with the `-f` flag. Currently, two formats are supported. The first format is `text`, which is the default and uses the existing terminal output format. The other is `json`, which emits JSON. The output is a stream of objects, allowing for a future streaming output mode. Each object uses the following example schema: ```json { "checker": "staticcheck", "code": "SA4006", "location": { "file": "/usr/lib/go/src/database/sql/sql_test.go", "line": 2701, "column": 5 }, "message": "this value of err is never used", "ignored": false } ``` ### Control over the exit code of megacheck Megacheck, the tool for running multiple checkers at once, now has per checker flags for controlling the overall exit code. Previously, megacheck would exit non-zero if any checker found a problem. Now it is possible to configure for each checker whether it should cause a non-zero exit, by using the `-<checker>.exit-non-zero` flags. This flag defaults to false for _gosimple_ and to true for the other checkers. ## Changes to checks ### Support for `NoCopy` in _unused_ The _unused_ tool now understands `NoCopy` sentinel types. The `NoCopy` type, which is canonically a struct with no fields and only a single, empty `Lock` method, can be used to mark structs as not safe for copying. By declaring a field of this type, _go vet_ will complain when it sees instances of the struct being copied. In the past, _unused_ marked these fields as unused, now it ignores them. ### Detection of deprecated identifiers {{< check "SA1019" >}} now correctly identifies deprecated methods, in addition to fields and package-level objects. Additionally, staticcheck now keeps track of when each identifier in the Go standard library was deprecated, so that using `-go <version>` can correctly ignore deprecation warnings that don't apply to the targeted Go version. ### Other - {{< check "SA4017" >}} no longer reports pure functions that are stubs – functions that immediately panic or return a constant. - {{< check "SA5007" >}} no longer flags infinite recursion when the function call is spawned as a new goroutine. - {{< check "SA6002" >}} now recognizes that `unsafe.Pointer` is a pointer type. - {{< check "S1005" >}} no longer suggests `for range` when targeting a version older than Go 1.4. - {{< check "S1026" >}} has been removed. In some rare instances, copying a string is necessary, and all common ways of doing this were incorrectly flagged by the check. ## Other changes - The `-ignore` flag now supports ignoring checks in all packages, by using `*` as the path. - `//line` directives are now being ignored when reporting problems. That is, problems will always be reported for the actual position in the Go files they occur. - From now on, only the first compilation error encountered will be reported. The tools expect to be run on valid Go code and there was little (if any) value in reporting all compilation errors encountered, especially because simple errors can lead to many follow-up errors. ## Staticcheck 2017.2.1 Release Notes {#2017.2.1} The 2017.2.1 release of the staticcheck suite of tools is the first bug fix release, fixing one bug. ### Fixed bugs Staticcheck 2017.2 made the detection of deprecated objects Go-version aware. Unfortunately, this only worked correctly for fields and methods, but not package-level objects. This release fixes that. ## Staticcheck 2017.2.2 Release Notes {#2017.2.2} The 2017.2.2 release of the staticcheck suite of tools is the second bug fix release, fixing several bugs. ### Fixed bugs - _unused_: correctly apply the NoCopy exemption when using the `-exported` flag. - _keyify_: support external test packages (`package foo_test`) - _staticcheck_: disable {{< check "SA4005" >}} – the check, in its current form, is prone to false positives and will be reimplemented in a future release. golang-honnef-go-tools-2024.1/website/content/changes/2019.1.md000066400000000000000000000163421465704072200237020ustar00rootroot00000000000000--- title: Staticcheck 2019.1 release notes linkTitle: 2019.1 weight: -2 --- ## Big restructuring At the core of the 2019.1 release lies the grand restructuring of all of the Staticcheck tools. All of the individual checkers, as well as megacheck, have been merged into a single tool, which is simply called `staticcheck`. From this point forward, `staticcheck` will be _the_ static analyzer for Go code. It will cover all of the existing categories of checks – bugs, simplifications, performance – as well as future categories, such as the new style checks. This change makes a series of simplifications possible. Per-tool command line flags in megacheck have been replaced with unified flags (`-checks` and `-fail`) that operate on arbitrary subsets of checks. Consumers of the JSON output no longer need to know about different checker names and can instead rely solely on user-controllable severities. And not to be neglected: gone is the silly name of _megacheck_. This change will require some changes to your pipelines. Even though the gosimple, unused, and megacheck tools still exist, they have been deprecated and will be removed in the next release of staticcheck. Additionally, megacheck's `-.exit-non-zero` flags have been rendered inoperable. Instead, you will have to use the `-fail` flag. Furthermore,, `-fail` defaults to `all`, meaning all checks will cause non-zero exiting. Previous versions of megacheck had different defaults for different checkers, trying to guess the user's intention. Instead of guessing, staticcheck expects you to provide the correct flags. Since all of the tools have been merged into staticcheck, it will no longer run just one group of checks. This may lead to additional problems being reported. To restore the old behavior, you can use the new `-checks` flag. `-checks "SA*"` will run the same set of checks that the old staticcheck tool did. The same flag should be used in place of megacheck's – now deprecated – `-.enabled` flags. Details on all of the command-line flags can be found [in the documentation.]({{< relref "/docs/#cli" >}}) ## Configuration files Staticcheck 2019.1 adds support for per-project configuration files. With these it will be possible to standardize and codify linter settings, the set of enabled checks, and more. Please see the [documentation page on configuration]({{< relref "/docs/#configuration" >}}) for all the details! ## Build system integration Beginning with this release, staticcheck calls out to the tools of the underlying build system (`go` for most people) to determine the list of Go files to process. This change should not affect most people. It does, however, have some implications: the system that staticcheck runs on needs access to a full Go toolchain – just the source code of the standard library no longer suffices. Furthermore, setting `GOROOT` to use a different Go installation no longer works as expected. Instead, `PATH` has to be modified so that `go` resolves to the desired Go command. This change has been necessary to support Go modules. Additionally, it will allow us to support alternative build systems such as Bazel in the future. ## Handling of broken packages We have redesigned the way staticcheck handles broken packages. Previously, if you ran `staticcheck ...` and any package wouldn't compile, staticcheck would refuse to check any packages whatsoever. Now, it will skip broken packages, as well as any of their dependents, and check only the remaining packages. Any build errors that are encountered will be reported as problems. ## Checks ### New checks Staticcheck 2019.1 adds a new category of checks, ST1. ST1 contains checks for common style violations – poor variable naming, incorrectly formatted comments and the like. It brings the good parts of [golint](https://github.com/golang/lint) to staticcheck, and adds some checks of its own. In addition, some other checks have been added. {{< check "S1032" >}} recommends replacing `sort.Sort(sort.StringSlice(...))` with `sort.Strings(...)`; similarly for other types that have helpers for sorting. {{< check "SA9004" >}} flags groups of constants where only the first one is given an explicit type. {{< check "SA1025" >}} checks for incorrect uses of `(*time.Timer).Reset`. ### Changed checks Several checks have been tweaked, either making them more accurate or finding more issues. {{< check "S1002" >}} no longer applies to code in tests. While `if aBool == true` is usually an anti-pattern, it can feel more natural in unit tests, as it mirrors the `if got != want` pattern. {{< check "S1005" >}} now flags `for x, _ := range` because of the unnecessary blank assignment. {{< check "S1007" >}} no longer suggests using raw strings for regular expressions containing backquotes. {{< check "S1016" >}} now considers the targeted Go version. It will no longer suggest type conversions between struct types with different field tags unless Go 1.8 or later is being targeted. {{< check "SA1000" >}} now checks arguments passed to the `regexp.Match` class of functions. {{< check "SA1014" >}} now checks arguments passed to `(*encoding/xml.Decoder).DecodeElement`. {{< check "SA6002" >}} now realizes that unsafe.Pointer is a pointer. {{< check "U1000" >}} has fewer false positives in the presence of embedding. ### Removed checks {{< check "S1013" >}} has been removed, no longer suggesting replacing `if err != nil { return err }; return nil` with `return err`. This check has been the source of contention and more often than not, it reduced the consistency of the surrounding code. ## Deprecation notices This release deprecates various features of staticcheck. These features will be removed in the next release. As already explained earlier, the _unused_, _gosimple_, and _megacheck_ tools have been replaced by _staticcheck_. Similarly, the flags `-.enabled` and `-.exit-non-zero` have been replaced by `-checks` and `-fail`. Finally, the `-ignore` flag has been replaced by [linter directives]({{< relref "/docs/#ignoring-problems" >}}). ## Binary releases Beginning with this release, we're publishing [prebuilt binaries to GitHub](https://github.com/dominikh/go-tools/releases). These releases still require a functioning Go installation in order to operate, however. ## Other changes We've removed the `-min_confidence` flag. This flag hasn't been doing anything for years. A new formatter called [Stylish]({{< relref "/docs/running-staticcheck/cli/formatters" >}}) (usable with `-f stylish`) provides output that is designed for easier consumption by humans. Due to the restructuring of checkers, the `checker` field in JSON output has been replaced with the `severity` field. ## Staticcheck 2019.1.1 Release Notes {#2019.1.1} The 2019.1.1 release of Staticcheck is the first bug fix release, fixing several bugs and improving performance. ### Changes - The ST category of checks no longer flag style issues of aliased types when the aliased type exists in a package we aren't explicitly checking. This avoids crashes and erratic error reports. - Compiler errors now have correct position information. - A crash in the Stylish reporter has been fixed. - We no longer flag unused objects that belong to cgo internals. - The {{< check "U1000" >}} check has been optimized, reducing its memory usage and runtime. golang-honnef-go-tools-2024.1/website/content/changes/2019.2.md000066400000000000000000000367551465704072200237150ustar00rootroot00000000000000--- title: Staticcheck 2019.2 release notes linkTitle: 2019.2 weight: -3 --- ## Performance improvements {#performance} Staticcheck 2019.2 brings major performance improvements and a reduction in memory usage. Staticcheck has been redesigned to only keep those packages in memory that are actively being processed. This allows for much larger workspaces to be checked in one go. While previously it may have been necessary to split a list of packages into many invocations of `staticcheck`, this is now handled intelligently and efficiently by Staticcheck itself. In particular, memory usage is now closely tied to parallelism: having more CPU cores available allows for more packages to be processed in parallel, which increases the number of packages held in memory at any one time. Not only does this make good use of available resources – systems with more CPU cores also tend to have more memory available – it also exposes a single, easy to use knob for trading execution time for memory use. By setting `GOMAXPROCS` to a value lower than the number of available cores, memory usage of Staticcheck will be reduced, at the cost of taking longer to complete. We've observed reductions in memory usage of 2x to 8x when checking large code bases.
    Package 2019.1.1 2019.2¹ Change
    net/http 3.543 s / 677 MB 3.747 s / 254 MB +5.76% / -62.48%
    strconv 1.628 s / 294 MB 1.678 s / 118 MB +3.07% / -59.86%
    image/color 1.304 s / 225 MB 1.702 s / 138 MB +30.52% / -38.67%
    std 26.234 s / 3987 MB 19.444 s / 1054 MB -25.88% / -73.56%
    github.com/cockroachdb/cockroach/pkg/... 88.644 s / 15959 MB 93.798 s / 4156 MB +5.81% / -73.96%
    ¹: The fact cache was empty for all benchmarks.
    In addition, Staticcheck now employs caching to speed up repeated checking of packages. In the past, when checking a package, all of its dependencies had to be loaded from source and analyzed. Now, we can make use of Go's build cache, as well as cache our own analysis facts. This makes Staticcheck behave a lot more like `go build`, where repeated builds are much faster. | Package | Uncached | Cached | Change | |------------------------------------------|--------------------|--------------------|------------------------| | net/http | 3.747 s / 254 MB | 1.545 s / 195 MB | -58.77% / -23.23% | | strconv | 1.678 s / 118 MB | 0.495 s / 57 MB | -70.5% / -51.69% | | image/color | 1.702 s / 138 MB | 0.329 s / 31 MB | -80.67% / -77.54% | | std | 19.444 s / 1054 MB | 15.099 s / 887 MB | -22.35% / -15.84% | | github.com/cockroachdb/cockroach/pkg/... | 93.798 s / 4156 MB | 47.205 s / 2516 MB | -49.67% / -39.46% | This combination of improvements not only compensates for the increased memory usage that 2019.1 introduced, it also brings the memory usage and execution times way below the levels of those seen in the 2017.2 release, which had previously been our most efficient release. It should be noted that all of these improvements are part of the `staticcheck` command itself, not the individual checks. Tools such as golangci-lint will have to replicate our efforts to benefit from these improvements. ## The go/analysis framework {#go-analysis} Part of the redesign of Staticcheck involved porting our code to the [go/analysis](https://godoc.org/golang.org/x/tools/go/analysis) framework. The go/analysis framework is a framework for writing static analysis tools such as Staticcheck and go vet. It provides an API that enables interoperability between different analyses and analysis drivers – drivers being the code that actually executes analyses. The intention is that any driver can trivially use any analysis that is implemented using go/analysis. With the exception of {{< check "U1000" >}}, all of our checks are now go/analysis analyses. Furthermore, the `staticcheck` command is now a go/analysis driver. With our move to this framework, we enable other drivers to reuse our checks without having to patch them. This should be of particular interest to golangci-lint, which previously took to patching Staticcheck, sometimes in subtly incorrect ways. Another high-profile go/analysis driver is gopls, the Go language server. It will now be much easier for gopls to use Staticcheck to analyze code, should it so desire. Theoretically it would also allow us to use third-party analyses as part of Staticcheck. Due to quality control reasons, however, we will likely refrain from doing so. Nonetheless it would be trivial for users to maintain internal forks of `cmd/staticcheck` that use third-party analyses. ## Improvements to the CLI {#cli} We've made several minor improvements to the command-line interface of `staticcheck` that improve usability and debuggability. ### SIGINFO handler {#cli-siginfo} Upon receiving the SIGINFO signal – or SIGUSR1 on platforms that lack SIGINFO – Staticcheck will dump statistics, such as the current phase and how many packages are left to analyze. ```text Packages: 37/619 initial, 38/1011 total; Workers: 8/8; Problems: 73 ``` ### Explaining checks {#cli-explain} Using the new `-explain` flag, a check's documentation can be displayed right in the terminal, eliminating the need to visit the website. ```text $ staticcheck -explain S1007 Simplify regular expression by using raw string literal Raw string literals use ` instead of " and do not support any escape sequences. This means that the backslash (\) can be used freely, without the need of escaping. Since regular expressions have their own escape sequences, raw strings can improve their readability. Before: regexp.Compile("\\A(\\w+) profile: total \\d+\\n\\z") After: regexp.Compile(`\A(\w+) profile: total \d+\n\z`) Available since 2017.1 ``` ### -debug.version {#cli-debug-version} The `-debug.version` flag causes `staticcheck` to print detailed version information, such as the Go version used to compile it, as well as the versions of all dependencies if built using Go modules. This feature is intended for debugging issues, and we will ask for its output from users who file issues. ```text $ staticcheck -debug.version staticcheck (devel, v0.0.0-20190602125119-5a4a2f4a438d) Compiled with Go version: go1.12.5 Main module: honnef.co/go/tools@v0.0.0-20190602125119-5a4a2f4a438d (sum: h1:U5vSGN1Bjr0Yd/4pRcp8iRUCs3S5TIPzoAeTEFV2aiU=) Dependencies: github.com/BurntSushi/toml@v0.3.1 (sum: h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=) golang.org/x/tools@v0.0.0-20190530171427-2b03ca6e44eb (sum: h1:mnQlcVx8Qq8L70HV0DxUGuiuAtiEHTwF1gYJE/EL9nU=) ``` ### Enabling unused's whole program mode {#cli-unused} When we merged `unused` into `staticcheck`, we lost the ability to specify the `-exported` flag to report unused exported identifiers. Staticcheck 2019.2 restores this ability with the new `-unused.whole-program` flag. ### Range information in diagnostics {#cli-ranges} Many of our checks now emit `[start, end]` ranges for findings instead of just positions. These ranges can be accessed via the `json` output formatter, as well as by using `go/analysis.Diagnostic` directly, such as in gopls. Note that not all checks are able to emit range information. ## Installing Staticcheck as a module {#module} As part of the 2019.2 release, we've turned Staticcheck into a Go module. From now on, if using Go modules, you can install specific versions of Staticcheck with `go get honnef.co/go/tools/cmd/staticcheck@`, though do note that older releases do not have a `go.mod` file. You can still download them as modules, but Go will record indirect dependencies in the main module's `go.mod` file, and no minimum versions are specified. Staticcheck will not use Semantic Versioning for its releases. It is our belief that Semver is a poor fit for applications and is more suited towards libraries. For example, almost every release of Staticcheck has backwards incompatible changes to some APIs that aren't meant for public consumption, but which we expose nevertheless so that tinkerers can use them. However, we use so-called _pre-release versions_ of the form `v0.0.0-2019.2`. These allow us to embed our versioning scheme in that of Semver, with correct sorting and updating of versions. Furthermore, these versions ensure that `go get ...`, if not specifying an explicit version (that is, if using the query `latest`), will install the latest released version of Staticcheck and not the master branch. While you can use these pre-release version numbers directly, you can also use the canonical versions of the form `2019.2` instead. The Go tool will automatically translate these versions to the appropriate pre-releases. To install the master branch, use `go get honnef.co/go/tools/cmd/staticcheck@master` ## Removal of deprecated functionality {#deprecated} Staticcheck 2019.1 deprecated the `unused`, `gosimple`, and `megacheck` utilities, as they have been merged into `staticcheck`. Furthermore, it deprecated the `-ignore` flag, which has been replaced by [linter directives]({{< relref "/docs/#ignoring-problems" >}}). This release no longer includes these deprecated utilities, nor does it provide the deprecated flag. ## Checks {#checks} ### New checks {#checks-new} Numerous new checks have been added in this release: - {{< check "S1033" >}} flags unnecessary guards around calls to `delete`. - {{< check "S1034" >}} simplifies type switches involving redundant type assertions. - {{< check "SA1026" >}} flags attempts at marshaling invalid types. - {{< check "SA1027" >}} flags incorrectly aligned atomic accesses. - {{< check "SA4020" >}} flags unreachable case clauses in type switches. - {{< check "SA4021" >}} flags calls to append with a single argument, as `x = append(y)` is equivalent to `x = y`. - {{< check "SA5008" >}} flags certain kinds of invalid struct tags. - {{< check "SA5009" >}} verifies the correctness of Printf calls. - {{< check "SA6005" >}} flags inefficient string comparisons involving `strings.ToLower` or `strings.ToUpper` when they can be replaced with `strings.EqualFold`. - {{< check "SA9005" >}} flags attempts at marshaling structs with no public fields nor custom marshaling. - {{< check "ST1017" >}} flags so-called [yoda conditions](https://en.wikipedia.org/wiki/Yoda_conditions), which take the form of `if 42 == x`. - {{< check "ST1018" >}} flags string literals containing zero-width characters. ### Changed checks {#checks-changed} Several checks have been improved: - {{< check "SA1019" >}} now flags imports of deprecated packages. - {{< check "SA4000" >}} no longer flags comparisons between custom float types. Additionally, it avoids a false positive caused by cgo. - {{< check "SA4006" >}} no longer flags unused values in code generated by goyacc. This avoids noise caused by the nature of the generated state machine. - {{< check "ST1005" >}} no longer flags error messages that start with capitalized type names. - {{< check "ST1006" >}} no longer flags receiver names in generated code. - {{< check "SA5002" >}} no longer suggests replacing `for false {` with `for {`. - Added "SIP" and "RTP" as default initialisms to {{< check "ST1003" >}}. - {{< check "SA1006" >}}, {{< check "SA4003" >}}, {{< check "S1017" >}}, and {{< check "S1020" >}} match more code patterns. - {{< check "S1021" >}} is less eager to merge declarations and assignments when multiple assignments are involved. - {{< check "U1000" >}} has been rewritten, eliminating a variety of false positives. ## Sustainable open source and a personal plea {#sustainable-open-source} Staticcheck is an open source project developed primarily by me, Dominik Honnef, in my free time. While this model of software development has gotten increasingly common, it is not very sustainable. Time has to be split between open source work and paid work to sustain one's life. This is made especially unfortunate by the fact that hundreds of companies rely on open source each day, but few consider giving back to it, even though it would directly benefit their businesses, ensuring that the software they rely on keeps being developed. I have long been soliciting donations for Staticcheck [on Patreon](https://www.patreon.com/dominikh) to make its development more sustainable. A fair number of individuals have generously pledged their support and I am very grateful to them. Unfortunately, only few companies support Staticcheck's development, and I'd like for that to change. To people who are familiar with Patreon, it might've always seemed like an odd choice for a software project. Patreon focuses on art and creative work, and on individuals supporting said work, not companies. I am therefore excited to announce my participation in [GitHub Sponsors](https://github.com/sponsors), a new way of supporting developers, directly on GitHub. GitHub Sponsors allows you to easily support developers by sponsoring them on a monthly basis, [via a few simple clicks.](https://github.com/users/dominikh/sponsorship) It is fully integrated with the platform and can use your existing billing information, making it an effortless process. **To encourage more company sponsorships I offer to display your company's logo prominently on [Staticcheck's website](https://staticcheck.dev/)** for [$250 USD a month](https://github.com/users/dominikh/sponsorship?utf8=%E2%9C%93&tier_id=MDIyOk1hcmtldHBsYWNlTGlzdGluZ1BsYW4yNTAy&editing=false), to show my appreciation for your contribution and to show to the world how much you care about code quality. Please don't hesitate [contacting me directly](mailto:dominik@honnef.co) if neither GitHub Sponsors nor Patreon seem suitable to you but you'd like to support me nevertheless. I am sure we can work something out. ## Staticcheck 2019.2.1 release notes {#2019.2.1} The 2019.2 release has an unfortunate bug that prevents Staticcheck from running on 32-bit architectures, causing it to crash unconditionally. This release fixes that crash. ## Staticcheck 2019.2.2 release notes {#2019.2.2} Staticcheck 2019.2.2 contains the following user-visible fixes: - {{< check "S1008" >}} now skips if/else statements where both branches return the same value. - {{< check "SA4006" >}} now considers a value read when a switch statement reads it, even if the switch statement has no branches. - 2019.2 introduced a bug that made it impossible to enable non-default checks via configuration files. This is now possible again. - 2019.2 introduced a bug that made the `-tags` command line argument ineffective, making it impossible to pass in build tags. This is now possible again. - From this release onward, we will use pseudo versions of the form `v0.0.1-.` instead of `v0.0.0-.`. This fixes an issue where `go get` would prefer an older commit over a newer released version due to the way versions sort. ## Staticcheck 2019.2.3 release notes {#2019.2.3} Staticcheck 2019.2.3 is a re-release of 2019.2.2. Its pre-built binaries, which can be found on GitHub, have been built with Go 1.13, to enable checking of code that uses language features introduced in Go 1.13. golang-honnef-go-tools-2024.1/website/content/changes/2020.1.md000066400000000000000000000225521465704072200236720ustar00rootroot00000000000000--- title: Staticcheck 2020.1 release notes linkTitle: 2020.1 weight: -4 --- ## Introduction to Staticcheck 2020.1 {#introduction} Staticcheck 2020.1 introduces UI improvements, speed enhancements, and a number of [new](#checks-new) as well as [improved](#checks-changed) checks. Additionally, it is the first release to support the upcoming Go 1.14. ## UI improvements {#ui-improvements} We've improved the output of the `staticcheck` command as well as Staticcheck's integration with [gopls](https://github.com/golang/tools/tree/master/gopls) to make it easier to understand the problems that are being reported. Related information describes the source of a problem, or why Staticcheck believes that there is a problem. Take the following piece of code for example: ```go func fn(x *int) { if x == nil { log.Println("x is nil, returning") } // lots of code here log.Println(*x) } ``` Staticcheck 2020.1 will produce the following output: ```text foo.go:6:14: possible nil pointer dereference (SA5011) foo.go:2:5: this check suggests that the pointer can be nil ``` The actual problem that is being reported is the "possible nil pointer dereference". Staticcheck also explains why it believes that `x` might be nil, namely the comparison on line 2. When using the [`text`]({{< relref "/docs/running-staticcheck/cli/formatters#text" >}}) or [`stylish`]({{< relref "/docs/running-staticcheck/cli/formatters#stylish" >}}) formatters, related information will appear as indented lines. The [`json`]({{< relref "/docs/running-staticcheck/cli/formatters#json" >}}) formatter adds a new field `related` to problems, containing position information as well as the message. Editors that use gopls will also display the related information. Related information should make it easier to understand why Staticcheck is flagging code, and how to fix problems. Integration with gopls has seen some other improvements as well¹. We now emit better position information that more accurately reflects the true source of a problem. The most obvious example is that a missing package comment will no longer underline the entire file. Similarly, invalid function arguments will be highlighted individually, instead of highlighting the call as a whole. Finally, some problems can now be automatically fixed by using quick fixes. ¹: due to the nature of Staticcheck's integration with gopls, gopls will need to update their dependency on Staticcheck before benefiting from these changes. ## Better caching {#caching} The 2019.2 release introduced caching to Staticcheck, greatly speeding up repeated runs. However, the caching only applied to dependencies; the packages under analysis still had to be analyzed anew on every invocation to compute the list of problems. Staticcheck 2020.1 introduces caching of problems found, so that repeat runs for unchanged packages are virtually instantaneous. ## Checks {#checks} ### New checks {#checks-new} Numerous new checks have been added in this release: - {{< check "S1035" >}} flags redundant calls to `net/http.CanonicalHeaderKey`. - {{< check "S1036" >}} flags unnecessary guards around map accesses. - {{< check "S1037" >}} flags unnecessarily elaborate ways of sleeping. - {{< check "S1038" >}} flags unnecessary uses of `fmt.Sprintf`, such as `fmt.Println(fmt.Sprintf(...))`. - {{< check "S1039" >}} flags uses of `fmt.Sprint` with single string literals. - {{< check "SA1028" >}} flags uses of `sort.Slice` on non-slices. - {{< check "SA1029" >}} flags inappropriate keys in calls to context.WithValue. - {{< check "SA4022" >}} flags comparisons of the kind `if &x == nil`. - {{< check "SA5010" >}} flags impossible type assertions. - {{< check "SA5011" >}} flags potential nil pointer dereferences. - {{< check "ST1019" >}} flags duplicate imports. - {{< check "ST1020" >}} checks the documentation of exported functions. - {{< check "ST1021" >}} checks the documentation of exported types. - {{< check "ST1022" >}} checks the documentation of exported variables and constants. {{< check "ST1020" >}}, {{< check "ST1021" >}} and {{< check "ST1022" >}} are not enabled by default. ### Changed checks {#checks-changed} Several checks have been improved: - {{< check "S1036" >}} detects more kinds of unnecessary guards around map accesses. - {{< check "S1008" >}} reports more easily understood diagnostics. - {{< check "S1025" >}} no longer suggests using `v.String()` instead of `fmt.Sprintf("%s", v)` when `v` is a `reflect.Value`. `fmt` gives special treatment to `reflect.Value` and the two results differ. - {{< check "SA1015" >}} no longer flags uses of `time.Tick` in packages that implement [Cobra](https://github.com/spf13/cobra) commands. - {{< check "SA1019" >}} no longer misses references to deprecated packages when said packages have been vendored. - {{< check "SA4000" >}} no longer flags comparisons of the kind `x == x` and `x != x` when `x` has a compound type involving floats. - {{< check "SA4003" >}} no longer flags comparisons of the kind `x <= 0` when `x` is an unsigned integer. While it is true that `x <= 0` can be written more specifically as `x == 0`, this is not a helpful suggestion in reality. A lot of people use `x <= 0` as a defensive measure, in case `x` ever becomes signed. Also, unlike all the other warnings made in the check, `x <= 0` is neither a tautology nor a contradiction, it is merely less precise than it could be. - {{< check "SA4016" >}} now detects silly bitwise ops of the form `x & k` where `k` is defined as `const k = iota`. - {{< check "SA4018" >}} no longer flags self-assignments involving side effects; for example, it won't flag `x[fn()] = x[fn()]` if `fn` isn't pure. - {{< check "SA5008" >}} now permits duplicate instances of various struct tags used by `github.com/jessevdk/go-flags`. - {{< check "SA5009" >}} now correctly recognizes that `unsafe.Pointer` is a pointer type that can be used with verbs such as `%p`. Furthermore, it validates calls to `golang.org/x/xerrors.Errorf`. - {{< check "SA5009" >}} now understands `fmt.Printf` verbs that were changed and added in Go 1.13. Specifically, it now recognizes the new `%O` verb, and allows the use of `%x` and `%X` on floats and complex numbers. - {{< check "ST1003" >}} has learned about several new initialisms. - {{< check "ST1011" >}} no longer misses variable declarations with inferred types. - {{< check "ST1016" >}} now ignores the names of method receivers of methods declared in generated files. - {{< check "ST1020" >}}, {{< check "ST1021" >}}, and {{< check "ST1022" >}} no longer enforce comment style in generated code. ## General bug fixes {#bugs} The following bugs were fixed: - A race condition in the {{< check "U1000" >}} check could occasionally lead to sporadic false positives. - Some files generated by _goyacc_ weren't recognized as being generated. - `staticcheck` no longer fails to check packages that consist exclusively of tests. ## Staticcheck 2020.1.1 release notes {#2020.1.1} The 2020.1 release neglected to update the version string stored in the binary, causing `staticcheck -version` to incorrectly emit `(no version)`. ## Staticcheck 2020.1.2 release notes {#2020.1.2} The 2020.1.1 release incorrectly identified itself as version 2020.1. ## Staticcheck 2020.1.3 release notes {#2020.1.3} This release fixes two bugs involving `//lint:ignore` directives: - When ignoring U1000 and checking a package that contains tests, Staticcheck would incorrectly complain that the linter directive didn't match any problems, even when it did. - On repeated runs, the position information for a this linter directive didn't match anything report would either be missing, or be wildly incorrect. ## Staticcheck 2020.1.4 release notes {#2020.1.4} This release adds special handling for imports of the deprecated `github.com/golang/protobuf/proto` package. [github.com/golang/protobuf](https://github.com/golang/protobuf) has deprecated the `proto` package, but their `protoc-gen-go` still imports the package and uses one of its constants, to enforce a weak dependency on a sufficiently new version of the legacy package. Staticcheck would flag the import of this deprecated package in all code generated by protoc-gen-go. Instead of forcing the project to change their project structure, we choose to ignore such imports in code generated by protoc-gen-go. The import still gets flagged in code not generated by protoc-gen-go. You can find more information about this in the [upstream issue](https://github.com/golang/protobuf/issues/1077). ## Staticcheck 2020.1.5 release notes {#2020.1.5} This release fixes a [crash in the pattern matching engine]({{< issueref 806 >}}) and a [false positive in SA4006]({{< issueref 733 >}}). ## Staticcheck 2020.1.6 release notes {#2020.1.6} This release makes the following fixes and improvements: - Staticcheck no longer panics when encountering files that have the following comment: `// Code generated DO NOT EDIT.` - {{< check "SA4016" >}} no longer panics when checking bitwise operations that involve dot-imported identifiers. - Fixed the suggested fix offered by {{< check "S1004" >}}. - Fixed a false positive involving byte arrays in {{< check "SA5009" >}}. - Fixed a false positive involving named byte slice types in {{< check "SA5009" >}}. - Added another heuristic to avoid flagging function names in error messages in {{< check "ST1005" >}}. - {{< check "SA3000" >}} will no longer flag missing calls to `os.Exit` in `TestMain` functions if targeting Go 1.15 or newer. golang-honnef-go-tools-2024.1/website/content/changes/2020.2.md000066400000000000000000000410301465704072200236630ustar00rootroot00000000000000--- title: Staticcheck 2020.2 release notes linkTitle: "2020.2 (v0.1.0)" weight: -5 --- ## Performance improvements {#performance-improvements} The primary focus of this release is a major improvement in performance, significantly reducing memory usage while also reducing runtimes.
    Uncached, GOMAXPROCS=1
    Package 2020.1.6 2020.2 Delta Stats
    image/color 2.41s ±19% 2.00s ±14% -17.08% p=0.000, n=10+10
    k8s.io/kubernetes/pkg/... 276s ± 1% 219s ± 1% -20.62% p=0.000, n=10+10
    net/http 6.18s ± 1% 5.61s ± 5% -9.21% p=0.000, n=8+10
    std 49.5s ± 1% 42.5s ± 1% -14.04% p=0.000, n=9+10
    strconv 2.49s ± 9% 2.19s ±12% -12.08% p=0.001, n=10+10
    image/color 167MB ±26% 146MB ±19% -12.62% p=0.043, n=10+10
    k8s.io/kubernetes/pkg/... 2.14GB ± 1% 0.45GB ±13% -79.09% p=0.000, n=10+10
    net/http 216MB ± 6% 166MB ±18% -23.11% p=0.000, n=10+10
    std 972MB ± 3% 284MB ± 9% -70.82% p=0.000, n=8+10
    strconv 155MB ±21% 139MB ±29% ~ p=0.063, n=10+10
    Cached, GOMAXPROCS=1
    Package 2020.1.6 2020.2 Delta Stats
    image/color 160ms ± 0% 107ms ± 7% -33.13% p=0.000, n=8+10
    k8s.io/kubernetes/pkg/... 12.7s ± 1% 6.9s ± 1% -45.26% p=0.000, n=9+10
    net/http 370ms ± 0% 230ms ± 0% -37.84% p=0.000, n=8+8
    std 2.52s ± 1% 1.31s ± 1% -48.13% p=0.000, n=10+9
    strconv 164ms ± 4% 110ms ± 0% -32.93% p=0.000, n=10+10
    image/color 38.6MB ± 4% 20.8MB ± 1% -45.96% p=0.000, n=9+10
    k8s.io/kubernetes/pkg/... 863MB ± 4% 283MB ± 2% -67.28% p=0.000, n=10+10
    net/http 70.5MB ± 5% 25.8MB ± 2% -63.48% p=0.000, n=10+9
    std 243MB ±16% 73MB ± 8% -70.00% p=0.000, n=10+10
    strconv 37.2MB ± 2% 21.3MB ± 1% -42.76% p=0.000, n=9+10
    Uncached, GOMAXPROCS=32
    Package 2020.1.6 2020.2 Delta Stats
    image/color 1.19s ±21% 1.06s ±12% ~ p=0.115, n=10+8
    k8s.io/kubernetes/pkg/... 27.0s ± 2% 22.4s ± 2% -16.96% p=0.000, n=10+10
    net/http 2.24s ±11% 2.23s ±10% ~ p=0.870, n=10+10
    std 7.14s ± 5% 5.10s ± 9% -28.56% p=0.000, n=10+9
    strconv 1.24s ±26% 1.18s ±21% ~ p=0.753, n=10+10
    image/color 143MB ± 7% 141MB ± 6% ~ p=0.515, n=8+10
    k8s.io/kubernetes/pkg/... 5.77GB ± 6% 2.76GB ± 4% -52.25% p=0.000, n=10+10
    net/http 284MB ±10% 226MB ±14% -20.38% p=0.000, n=10+10
    std 1.74GB ±10% 1.15GB ±14% -34.11% p=0.000, n=10+10
    strconv 148MB ±18% 144MB ±16% ~ p=0.579, n=10+10
    Cached, GOMAXPROCS=32
    Package 2020.1.6 2020.2 Delta Stats
    image/color 96.0ms ± 6% 80.0ms ± 0% -16.67% p=0.000, n=10+9
    k8s.io/kubernetes/pkg/... 4.64s ± 1% 3.88s ± 0% -16.22% p=0.000, n=9+8
    net/http 216ms ± 3% 167ms ± 4% -22.69% p=0.000, n=10+10
    std 1.09s ± 2% 0.96s ± 2% -12.20% p=0.000, n=10+10
    strconv 100ms ± 0% 87ms ± 8% -13.00% p=0.000, n=9+10
    image/color 46.4MB ± 3% 24.1MB ± 5% -48.08% p=0.000, n=8+10
    k8s.io/kubernetes/pkg/... 1.38GB ± 9% 0.27GB ± 1% -80.29% p=0.000, n=10+10
    net/http 80.7MB ±12% 31.4MB ± 2% -61.16% p=0.000, n=10+8
    std 363MB ±12% 75MB ± 7% -79.30% p=0.000, n=10+10
    strconv 48.5MB ± 6% 24.4MB ± 3% -49.72% p=0.000, n=10+10
    See commit [5cfc85b70e7b778eb76fd7338e538d7c9af21e4e](https://github.com/dominikh/go-tools/commit/5cfc85b70e7b778eb76fd7338e538d7c9af21e4e) for details on how these improvements have been achieved. Furthermore, Staticcheck 2020.2 will skip very large packages (currently packages that are 50 MiB or larger), under the assumption that these packages contain bundled assets and aren't worth analyzing. This might further reduce Staticcheck's memory usage in your projects. ## Changes to the detection of unused code {#unused} ### Removal of whole-program mode and changes to the handling of exported identifiers {#unused-whole-program} The [aforementioned performance improvements](#performance-improvements) necessitate some changes to the _U1000_ check (also known as _unused_). The most visible change is the removal of the _whole program_ mode. This mode, which analyzed an entire program and reported unused code even if it is exported, did not work well with the kind of caching that we use in Staticcheck. Even in previous versions, it didn't always work correctly and may have caused flaky results, depending on the state of the cache and the order of `staticcheck` invocations. The whole-program mode may be revived in the future as a standalone tool, with the understanding that this mode of operation is inherently more expensive than `staticcheck`. In the meantime, if you depend on this functionality and can tolerate its bugs, you should continue using Staticcheck 2020.1. As part of improving the correctness of U1000, changes were made to the normal mode as well. In particular, **all** exported package-level identifiers will be considered used from now on, even if these identifiers are declared in `package main` or tests, even if they are otherwise unused. Exported identifiers in `package main` can be used in ways invisible to us, for example via the `plugin` build mode. For tests, we would run into the same kind of issues as we did with the whole program mode. ### Improvements {#unused-improvements} The `//lint:ignore` directive now works more intelligently with the U1000 check. In previous versions, the directive would only suppress the output of a diagnostic. For example, for the following example ```go package pkg //lint:ignore U1000 This is fine. func fn1() { fn2() } func fn2() {} ``` Staticcheck would emit the following output: ```text foo.go:6:6: func fn2 is unused (U1000) ``` as it would only suppress the diagnostic for `fn1`. Beginning with this release, the directive instead actively marks the identifier as used, which means that any transitively used code will also be considered used, and no diagnostic will be reported for `fn2`. Similarly, the `//lint:file-ignore` directive will consider everything in a file used, which may transitively mark code in other files used, too. ## UI improvements {#ui-improvements} We've made some minor improvements to the output and behavior of the `staticcheck` command: - the command now prints instructions on how to look up documentation for checks - output of the `-explain` flag includes a link to the online documentation - a warning is emitted when a package pattern matches no packages - unmatched ignore directives cause `staticcheck` to exit with a non-zero status code ## Changes to versioning scheme {#versioning-improvements} Staticcheck releases have two version numbers: one meant for human consumption and one meant for consumption by machines, via Go modules. For example, the previous release was both `2020.1.6` (for humans) and `v0.0.1-2020.1.6` (for machines). In previous releases, we've tried to include the human version in the machine version, by using the `v0.0.1-` scheme. However, this scheme had various drawbacks. For this and future releases we've switched to a more standard scheme for machine versions: `v0..`. Minor will increase by one for every feature release of Staticcheck, and patch will increase by one for every bugfix release of Staticcheck, resetting to zero on feature releases. For example, this release is both `2020.2` and `v0.1.0`. A hypothetical `2020.2.1` would be `v0.1.1`, and `2021.1` will be `v0.2.0`. This new versioning scheme fixes various issues when trying to use Staticcheck as a Go module. It will also allow us to make true pre-releases in the future. Documentation on the website, as well as the output of `staticcheck -version`, will include both version numbers, to make it easier to associate the two. For detailed information on how we arrived at this decision, see the discussion on [issue 777]({{< issueref 777 >}}). ## Checks {#checks} ### New checks {#checks-new} The following new checks have been added: - {{< check "SA4023" >}} flags impossible comparisons of interface values with untyped nils - {{< check "SA5012" >}} flags function calls with slice arguments that aren't the right length - {{< check "SA9006" >}} flags dubious bit shifts of fixed size integers ### Changed checks {#checks-changed} Several checks have been improved: - {{< check "S1030" >}} no longer recommends replacing `m[string(buf.Bytes())]` with `m[buf.String()]`, as the former gets optimized by the compiler - {{< check "S1008" >}} no longer incorrectly suggests that the negation of `>=` is `<=` - {{< check "S1029" >}} and {{ check "SA6003" }} now also check custom types with underlying type `string` - {{< check "SA1019" >}} now recognizes deprecation notices that aren't in the last paragraph of a comment - {{< check "SA1019" >}} now emits more precise diagnostics for deprecated code in the standard library - {{< check "SA4006" >}} no longer flags assignments where the value is a typed nil - {{< check "SA5011" >}} is now able to detect more functions that never return, thus reducing the number of false positives - {{< check "SA9004" >}} no longer assumes that constants belong to the same group when they have different types - Automatic fixes for {{< check "SA9004" >}} inside gopls no longer incorrectly duplicate comments - {{< check "ST1003" >}} no longer complains about ALL_CAPS in variable names that don't contain any letters - Incorrect position information in various checks have been fixed - Crashes in various checks have been fixed ## Staticcheck 2020.2.1 release notes {#2020.2.1} This release eliminates some false negatives as well as false positives, makes the `staticcheck` command less noisy and fixes a potential security issue. - {{< check "SA4020" >}} no longer claims that `case nil` is an unreachable case in a type switch. - {{< check "S1025" >}} no longer marks uses of `Printf` as unnecessary when the printed types implement the `fmt.Formatter` interface. - Various checks may now detect bugs in conditional code that were previously missed. This was a regression introduced in Staticcheck 2020.1. - The `staticcheck` command no longer reminds the user of the `-explain` flag every time problems are found. This was deemed too noisy. - We've updated our dependency on `golang.org/x/tools` to guard against arbitrary code execution on Windows. Note that to be fully safe, you will also have to update your installation of Go. See the [Command PATH security in Go](https://blog.golang.org/path-security) article by the Go authors for more information on this potential vulnerability. ## Staticcheck 2020.2.2 release notes {#2020.2.2} This release fixes a rare crash in Staticcheck, reduces the number of false positives, and adds support for Go 1.16's `io/fs.FileMode` type. - {{< check "SA9002" >}} now supports the new `io/fs.FileMode` type in addition to `os.FileMode`. - Various checks no longer crash when analyzing nested function calls involving multiple return values. - {{< check "SA1006" >}} no longer flags `Printf` calls of the form `Printf(fn())` when `fn` has multiple return values. - Staticcheck now understands the effects of `github.com/golang/glog` on a function's control flow. ## Staticcheck 2020.2.3 release notes {#2020.2.3} This release fixes a false positive in U1000. See [issue 942]({{< issueref 942 >}}) for an example. ## Staticcheck 2020.2.4 release notes {#2020.2.4} This release fixes the following issues: - A false positive in {{< check "S1017" >}} when the `len` function has been shadowed - A bug in Staticcheck's intermediate representation that would lead to nonsensical reports claiming that a value isn't being used when it is definitely being used (see issues [949]({{< issueref 949 >}}) and [981]({{< issueref 981 >}}) for more information) - A rare crash (see issue [972]({{< issueref 972 >}}) for more information) golang-honnef-go-tools-2024.1/website/content/changes/2021.1.md000066400000000000000000000135501465704072200236710ustar00rootroot00000000000000--- title: Staticcheck 2021.1 release notes linkTitle: "2021.1 (v0.2.0)" weight: -6 --- ## UI improvements {#ui-improvements} The new `-list-checks` flag lists all available checks, showing each check's identifier and one-line description. You can use the existing `-explain` flag to find out more about each individual check. ### Targeted Go version {#targeted-go-version} Some checks in Staticcheck adjust their behavior based on the targeted Go version. For example, the suggestion to use `for range` instead of `for _ = range` does not apply to Go 1.3 and earlier. In the past, the default Go version that was targeted was the version that Staticcheck had been compiled with. For most users, this meant that it targeted the latest Go release. Going forward, we will default to the Go version declared in `go.mod` via the `go` directive. Even though this value does not exactly correspond to the module's minimum supported Go version, it is still a better apprximation than "whatever Go version Staticcheck has been compiled with", and should work fine for most users. As before, the targeted Go version can be explicitly set by using the `-go` flag. ## Checks {#checks} ### New checks {#checks-new} The following new checks have been added: - {{< check "S1040" >}} flags type assertions from an interface type to itself - {{< check "SA1030" >}} flags invalid arguments to various functions in the `strconv` package - {{< check "SA4005" >}} flags assignments to fields on value receivers that intended the receiver to be a pointer instead - {{< check "SA4024" >}} flags pointless comparisons of the values of `len` and `cap` with zero - {{< check "SA4025" >}} flags suspicious integer division that results in zero, such as `2 / 3` - {{< check "SA4026" >}} flags constant expressions that try to express [negative zero](https://en.wikipedia.org/wiki/Signed_zero) - {{< check "SA4027" >}} flags no-op attempts at modifying a `(*net/url.URL)`'s query string - {{< check "ST1023" >}} flags variable declarations of the form `var x T = v` where the type `T` is redundant; this check is disabled by default ### Changed checks {#checks-changed} The following checks have been improved: - {{< check "S1025" >}} now recommends converting byte slices to strings instead of using `fmt.Sprintf` - {{< check "S1008" >}} includes fewer unnecessary parentheses and double negations in its suggested fixes - {{< check "S1017" >}} is now able to flag calls that use string literals and integer literals - {{< check "SA9005" >}} now includes the value's type in its output - {{< check "ST1000" >}}, {{< check "ST1020" >}}, {{< check "ST1021" >}}, and {{< check "ST1022" >}} no longer flag effectively empty comments, including those that consist entirely of directives ## Restructured documentation {#documentation} The documentation on [the website](https://staticcheck.dev) has been restructured and hopefully made more approachable. Instead of being one long document, it is now split into multiple smaller articles. In the future, more articles that look at specific aspects of Staticcheck will be added. ## Better integration with gopls {#gopls} Several behind the scenes changes prepare this release for better integration with [gopls](https://github.com/golang/tools/blob/master/gopls/README.md). This will include more accurate severities for diagnostics as well as numerous new refactorings. These improvements will be part of a future gopls release. ## Deletion of rdeps {#rdeps} The rdeps tool has been deleted. This was a GOPATH-centric tool that allowed finding all reverse dependencies of a Go package. Both the move to Go modules as well as the emergence of much better tooling for inspecting dependencies (such as [goda](https://github.com/loov/goda)) has made rdeps redundant. ## Staticcheck 2021.1.1 release notes {#2021.1.1} This release adds support for new language features in Go 1.17, namely conversions from slices to array pointers, the unsafe.Add function, and the unsafe.Slice function. Additionally, it fixes the following false positives: - {{< check "ST1000" >}} no longer flags package docs that start with whitespace if they're otherwise well-formed. - {{< check "SA5002" >}} no longer prints one too many percent signs in its message. - {{< check "SA4000" >}} no longer flags comparisons between floats. - {{< check "SA4010" >}} no longer flags appends to slices that might share their backing array with other slices. - {{< check "SA5011" >}} no longer infers possible nil pointer dereferences from comparisons done outside of control flow constructs. This avoids false positives when using `assert`-style functions. See [issue 1022]({{< issueref 1022 >}}) for a concrete example. - {{< check "S1020" >}} no longer flags nested if statements when the inner statement has an else branch. - {{< check "SA5011" >}} no longer claims that indexing a nil slice will cause a nil pointer dereference. ## Staticcheck 2021.1.2 release notes {#2021.1.2} This release fixes the following false positives: - {{< check "SA4000" >}} no longer flags operations involving the `math/rand` package. This is to allow patterns such as `rand.Intn(2) - rand.Intn(2)`. - {{< check "S1019" >}} no longer recommends replacing `make(map[X]Y, 0)` with `make(map[X]Y)` – the latter may allocate a small starting size. - {{< check "SA1026" >}} now more accurately implements the behavior of `encoding/json` and `encoding/xml`, which will lead to fewer false positives involving method sets or embedding. It might also find bugs that it previously missed. - Checks that are sensitive to control flow, such as {{< check "SA5011" >}}, now recognize functions from `k8s.io/klog` and `go.uber.org/zap` that affect control flow (`Panic` and `Fatal` related functions.) Furthermore, it fixes the following crashes: - Using `//lint:ignore U1000` on a type alias would crash. - Converting a slice to an array pointer, where the array type is a named type, would crash. golang-honnef-go-tools-2024.1/website/content/changes/2022.1.md000066400000000000000000000143211465704072200236670ustar00rootroot00000000000000--- title: Staticcheck 2022.1 release notes linkTitle: "2022.1 (v0.3.0)" weight: -7 --- ## Improvements {#improvements} This release adds support for Go 1.18 and type parameters (generics). Furthermore, it adds two new flags for handling build tags, `-matrix` and `-merge`. Their use is extensively documented on the new [Build tags]({{< relref "/docs/running-staticcheck/cli/build-tags" >}}) page. Their intended use is for avoiding false positives when dealing with different build tags. Not tied directly to this release, but worth mentioning regardless: Staticcheck has an [official GitHub Action](https://github.com/dominikh/staticcheck-action) now, which may simplify your CI pipeline. Minor changes include slightly nicer output from `staticcheck -explain`, better error messages, and allowing whitespace in flags like `-checks`. ## Checks {#checks} ### New checks {#checks-new} The following new checks have been added: - {{< check "SA4028" >}} flags `x % 1`, which always yields zero, and is sometimes accidentally used instead of `x % 2` - {{< check "SA4029" >}} flags misuses of `sort.IntSlice` and related types - {{< check "SA4030" >}} flags misuses of `math/rand` that always generate zeros - {{< check "SA4031" >}} flags comparisons of never-nil values against nil - {{< check "SA9007" >}} flags attempts at deleting system directories - {{< check "SA9008" >}} flags accidental shadowing in the else branches of type assertions ### Changed checks {#checks-changed} The following checks have been improved: - {{< check "S1001" >}} now simplifies more loops - {{< check "S1038" >}} now simplifies formatted printing in `log` and `testing`, in addition to `fmt` - {{< check "SA1019" >}} no longer flags deprecated API in the Go standard library if it doesn't know when the API was deprecated. This is to avoid false positives when using older versions of Staticcheck on newer versions of Go, in particular Go's `master` branch. - {{< check "SA1020" >}} no longer flags `net/http.ListenAndServe` with a completely empty address - {{< check "ST1001" >}} various packages of `github.com/mmcloughlin/avo` have been whitelisted by default - {{< check "ST1008" >}} no longer flags functions that return `(..., error, bool)` - {{< check "ST1018" >}} no longer flags emoji sequences - {{< check "ST1023" >}} no longer makes erroneous suggestions - Numerous checks have a better understanding of integer literals and can detect mistakes involving unconventional literals such as `---1` instead of `-1` - Some runtime crashes have been fixed ## Staticcheck 2022.1.1 release notes {#2022.1.1} This release addresses the following false positives, crashes, and infinite loops: - {{< check "SA1026" >}} and {{< check "SA5008" >}} no longer get stuck in infinite loops when code attempts to marshal cyclic pointer types ({{< issue "1202" >}}) - U1000 no longer crashes when code contains mutually recursive type instantiations ({{< issue "1247" >}}) - U1000 no longer crashes when generic functions use composite literals of type parameter types ({{< commit "0ccdb5c9dad7e96a8e3a3136738192491b37dbdb" >}}) - {{< check "ST1021" >}} now understands type names that are also English articles ({{< issue "1187" >}}) - {{< check "SA4023" >}} no longer gets confused by the nilness of type parameters ({{< issue "1242" >}}) - Some checks no longer crash when trying to generate automated code fixes that involve function literals ({{< issue "1134" >}}) - {{< check "SA1026" >}} no longer claims that `encoding/json` cannot marshal generic maps ([golang/go#52467](https://golang.org/issue/52467)) - The `binary` format has been improved to handle OS-specific file paths correctly, in turn making the `-merge` flag work more reliably ({{< commit "1846305a946b13d350894512c7ac1e5ed71dc331" >}}) - When using the `-merge` or `-matrix` flags, diagnostics reported by {{< check "SA4008" >}} now have to occur in all runs to be reported, reducing the number of false positives ({{< commit "0e678cbe1c8b3f09ac481673453886b1afc9906a" >}}) - U1000 now understands struct type conversions involving type parameters, reducing the number of false positives ({{< commit "90804df0287d9265e565bcabbe19568efbe374fa" >}}) ## Staticcheck 2022.1.2 release notes {#2022.1.2} This release addresses the following false positives, crashes, infinite loops, and performance issues: - For certain packages that contain tens of thousands of types and methods, such as those generated by [ygot](https://github.com/openconfig/ygot), Staticcheck now finishes [much faster](https://github.com/openconfig/featureprofiles/pull/181#issuecomment-1119250596). - Several infinite loops when handling recursive type parameters have been fixed - {{< check "S1009" >}} no longer mistakes user-defined functions named `len` for the builtin ({{< issue "1181" >}}) - {{< check "ST1015" >}} no longer reorders `switch` statements if their order is significant due to the use of `fallthrough` ({{< issue "1188" >}}) - {{< check "SA1013" >}} now detects constants more robustly, avoiding both false negatives and false positives. Furthermore, it makes sure that offending methods implement io.Seeker and doesn't just rely on the name `Seek` ({{< issue "1213" >}}). - {{< check "SA5008" >}} now understands more third-party extensions to `json` struct tags - A crash involving functions named `_` has been fixed ({{< issue "1268" >}}) - A crash involving slicing type parameters of type `string | []byte` has been fixed ({{< issue "1270" >}}) - {{< check "SA1019" >}} now handles imports of deprecated standard library packages in the same way it handles other deprecated API, taking the targeted Go version into consideration ({{< issue "1117" >}}) Additionally it is strongly recommended to use Go 1.18.2 for building Staticcheck, as it fixes further generics-related bugs in the type checker. ## Staticcheck 2022.1.3 release notes {#2022.1.3} This release addresses the following issues: - Staticcheck maintains a cache to speed up repeated runs. This cache needs to be pruned regularly to keep its size in check. This is meant to happen automatically, but it hasn't since Staticcheck 2020.2. This release corrects that ({{< issue "1283" >}}.) - Some type sets containing both bidirectional and unidirectional channels would lead to panics ({{< issue "1304" >}}) golang-honnef-go-tools-2024.1/website/content/changes/2023.1.md000066400000000000000000000116571465704072200237010ustar00rootroot00000000000000--- title: Staticcheck 2023.1 release notes linkTitle: "2023.1 (v0.4.0)" weight: -8 --- Staticcheck 2023.1 adds support for Go 1.20, brings minor improvements to various checks, and replaces U1000 with a new implementation. ## Checks {#checks} ### Changed checks {#checks-changed} The following checks have been improved: - The wording of {{< check "S1001" >}} has been made clearer for cases involving arrays. Furthermore, it no longer suggests using `copy` when the function has been shadowed. - {{< check "S1011" >}} now recognizes index-based loops ({{< issue "881" >}}). - {{< check "SA1019" >}} no longer flags tests (internal or external) that use deprecated API from the package under test ({{< issue "1285" >}}). Furthermore, entire declaration groups (such as groups of constants) can now be marked as deprecated ({{< issue "1313" >}}). - {{< check "SA4017" >}} now detects more functions, including those in the `time` package ({{< issue "1353" >}}). Additionally, its wording has been made clearer. - {{< check "SA5010" >}} no longer gets confused by type assertions involving generic types ({{< issue "1354" >}}). - {{< check "ST1005" >}} no longer flags errors that start with alpha-numeric acronyms such as `P384`. - Improvements to our intermediate representation may allow various checks to find more problems. Staticcheck now knows about version 2 of the `k8s.io/klog` package, in particular which functions abort control flow ({{< issue "1307" >}}). In addition to these minor improvements, U1000 has been rewritten from the ground up, operating on a program representation more suited to the task. In practice this means that there will be fewer false positives and more true positives. Overall, the rewrite fixes at least eight known bugs, both ones that have been a nuisance for a while, as well as ones newly introduced by generics ({{< issue "507" >}}, {{< issue "633" >}}, {{< issue "810" >}}, {{< issue "812" >}}, {{< issue "1199" >}}, {{< issue "1249" >}}, {{< issue "1282" >}}, {{< issue "1333" >}}). ## Staticcheck 2023.1.1 release notes {#2023.1.1} This release fixes a crash, a false positive in U1000 ({{< issue "1360" >}}) and improves the way deprecated API is flagged ({{< issue "1318" >}}). When targeting a Go version that is older than the version that deprecated an API, {{< check "SA1019" >}} will no longer flag the use even if there is already an alternative available in the targeted Go version. For example, `math/rand.Seed` has been deprecated in Go 1.20, but an alternative has existed since Go 1.0. In the past, we would flag uses of `Seed` even if targeting e.g. Go 1.19, to encourage better forwards compatibility. This can lead to unnecessary churn, however, because the correct change may depend on the Go version in use. For example, for `Seed` before Go 1.20, the alternative is to use a separate instance of `math/rand.Rand`, whereas in Go 1.20, a possible alternative is to simply drop the call to `Seed`. ## Staticcheck 2023.1.2 release notes {#2023.1.2} This release fixes a bug that prevented the `binary` formatter from working ({{< issue "1370" >}}). ## Staticcheck 2023.1.3 release notes {#2023.1.3} This release fixes the following bugs: - A crash when embedding type aliases of unnamed types ({{< issue "1361" >}}) - A false positive in U1000, claiming that type aliases are unused ({{< issue "1365" >}}) - A bug in the `binary` formatter that prevented correct merging behavior for some checks ({{< issue "1372" >}}) ## Staticcheck 2023.1.4 release notes {#2023.1.4} This release **adds support for Go 1.21** and fixes the following bugs: - Three crashes when encountering unnecessarily parenthesized statements ({{< issue "1393" >}}, {{< issue "1400" >}}) - Unnecessarily high memory usage when analyzing composite literals such as `[]int{1<<31: 1}` ({{< issue "1393" >}}) - A false positive in {{< check "S1011" >}} when appending to a dynamic left-hand side ({{< issue "1399" >}}) - A crash involving generics ({{< issue "1410" >}}) - A false positive in {{< check "SA9001" >}} involving control flow statements ({{< issue "488" >}}) - A false positive in {{< check "ST1003" >}}, complaining about the names of fuzz functions ({{< issue "1420" >}})) ## Staticcheck 2023.1.5 release notes {#2023.1.5} This release fixes the following bug: - A crash involving methods named `_` ## Staticcheck 2023.1.6 release notes {#2023.1.6} This release fixes the following bugs: - A crash when using the upcoming Go 1.22 ({{< issue "1442" >}}) - A false positive in {{< check "SA9005" >}} when embedding basic types ({{< issue "1443" >}}) ## Staticcheck 2023.1.7 release notes {#2023.1.7} This release fixes some minor issues in Staticcheck's intermediate representation. Furthermore, it improves the way {{< check "QF1003" >}} generates suggested fixes, working around constraints in the language server protocol. The released binaries for this version have been built with Go 1.22 and should no longer panic when checking code targeting Go 1.22. golang-honnef-go-tools-2024.1/website/content/changes/2024.1.md000066400000000000000000000137221465704072200236750ustar00rootroot00000000000000--- title: Staticcheck 2024.1 release notes linkTitle: "2024.1 (v0.5.0)" weight: -9 --- ## Backwards incompatible changes Staticcheck 2024.1 contains the following backwards incompatible changes: - The `keyify` utility has been removed. The recommended alternative is gopls. - `staticcheck -merge` now exits with a non-zero status if any problems have been found. ## Improved Go 1.22 support This release updates Staticcheck's database of deprecated standard library APIs to cover the Go 1.22 release. Furthermore, checks have been updated to correctly handle the new "for" loop variable scoping behavior as well as ranging over integers. ## Added Go 1.23 support Staticcheck 2024.1 has full support for iterators / range-over-func. Furthermore, {{< check "SA1015" >}} will skip any code targeting Go 1.23 or newer, as it is now possible to use `time.Tick` without leaking memory. ## Improved handling of Go versions Go 1.21 more rigorously defined the meaning of the `go` directive in `go.mod` files, as well as its interactions with `//go:build go1.N` build constraints. The `go` directive now specifies a _minimum_ Go version for the module. Furthermore, it sets the language version that is in effect, which may change the semantics of Go code. For example, before Go 1.22, loop variables were reused across iterations, but since Go 1.22, loop variables only exist for the duration of an iteration. Modules that specify `go 1.22` will use the new semantics, while modules that specify an older version will not. Individual files can both upgrade and downgrade their language version by using `//go:build go1.N` directives. In a module that requires Go 1.22, a file specifying Go 1.21 will experience the old loop variable semantics, and vice versa. Because the Go module as a whole still specifies a minimum version, even files specifying an older version will have access to the standard library of the minimum version. Staticcheck 2024.1 takes all of this into consideration when analyzing the behavior of Go code, when determining which checks are applicable, and when making suggestions. Older versions of Staticcheck were already aware of Go versions, but 2024.1 works on a more fine-grained, per-file basis, and differentiates between the pre- and post-1.21 semantics of the `go` directive. The `-go` command line flag continues to exist. It will override any module-based version selection. This is primarily useful for Go modules that target older Go versions (because here, the `go` directive didn't specify a _minimum_ version), or when working outside of Go modules. To prevent misinterpreting code, Staticcheck now refuses to analyze modules that require a version of Go that is newer than that with which Staticcheck was built. ## Checks ### New checks The following checks have been added: - {{< check "SA1031" >}} flags overlapping destination and source slices passed to certain encoding functions. - {{< check "SA1032" >}} flags calls to [`errors.Is`](https://pkg.go.dev/errors#Is) where the two arguments have been swapped. - {{< check "SA4032" >}} flags impossible comparisons of [runtime.GOOS](https://pkg.go.dev/runtime#GOOS) and [runtime.GOARCH](https://pkg.go.dev/runtime#GOARCH) based on the file's build tags. - {{< check "SA6006" >}} flags `io.WriteString(w, string(b))` as it would be both simpler and more efficient to use `w.Write(b)`. - {{< check "SA9009" >}} flags comments that look like they intend to be compiler directives but which aren't due to extraneous whitespace. ### Changed checks The following checks have been improved: - {{< check "QF1001" >}} no longer panics on expressions involving "key: value" pairs ({{< issue "1484" >}}). - {{< check "S1008" >}} now understands that some built-in functions never return negative values. For example, it now negates `len(x) > 0` as `len(x) == 0` ({{< issue "1422" >}}). - {{< check "S1009" >}} now flags unnecessary nil checks that involve selector expressions ({{< issue "1527" >}}). - {{< check "S1017" >}} no longer flags `if else` branches ({{< issue "1447" >}}). - {{< check "SA1006" >}} now detects more Printf-like functions from the standard library ({{< issue "1528" >}}). - {{< check "SA1015" >}} now skips any code targeting Go 1.23 or newer ({{< issue "1558" >}}). - {{< check "SA1029" >}} now flags uses of the empty struct (`struct{}`) as context keys ({{< issue "1504" >}}). - {{< check "SA4003" >}} now flags pointless integer comparisons that involve literals, not just constants from the `math` package ({{< issue "1470" >}}). - {{< check "SA4015" >}} now supports conversions that involve generics. - {{< check "SA4023" >}} no longer panics on type sets that contain arrays ({{< issue "1397" >}}). - {{< check "SA5001" >}} now emits a clearer message ({{< issue "1489" >}}). - {{< check "SA9003" >}} has been disabled by default because of too many noisy positives ({{< issue "321" >}}). - {{< check "ST1000" >}} now permits punctuation following the package name, as in "Package pkg, which ..." ({{< issue "1452" >}}). - {{< check "ST1018" >}} now accepts variation selectors in emoji and certain Arabic formatting characters in string literals ({{< issue "1456" >}}). - {{< check "ST1020" >}} no longer flags comments that start with a deprecation notice ({{< issue "1378" >}}). - {{< check "U1000" >}} handles generic interfaces slightly better, reducing the number of false positives. - Due to improvements in the intermediate representation, various checks may now detect more problems. ## Miscellaneous changes and fixes - The `keyify` utility has been deleted. This functionality is provided by gopls nowadays. - `staticcheck -merge` now exits with a non-zero exit status if any problems were found. This matches the behavior of non-merge uses. - Malformed `staticcheck.conf` files now cause more useful errors to be emitted. - Labeled statements with blank labels no longer cause panics. - Functions with named return parameters that never actually return no longer cause panics ({{< issue "1533" >}}). golang-honnef-go-tools-2024.1/website/content/changes/_index.md000066400000000000000000000001311465704072200244030ustar00rootroot00000000000000--- title: Release notes type: docs outputs: - html - RSS cascade: type: docs --- golang-honnef-go-tools-2024.1/website/content/contact.md000066400000000000000000000010411465704072200231610ustar00rootroot00000000000000--- title: "Contact" menu: main: weight: 3 pre: --- {{< blocks/section type="section" color="white" >}} Please contact me at dominik@honnef.co should you have any questions regarding this website or the services offered. The following information are provided to comply with § 5 Telemediengesetz. Dominik Honnef
    Bahnhofstraße 65
    45770 Marl
    Germany

    Email: dominik@honnef.co
    Phone: +49 151 178 067 90

    USt-IdNr: DE298968211 {{< /blocks/section >}} golang-honnef-go-tools-2024.1/website/content/docs/000077500000000000000000000000001465704072200221405ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/content/docs/_index.md000066400000000000000000000032101465704072200237240ustar00rootroot00000000000000--- title: "Welcome to Staticcheck" linkTitle: "Documentation" menu: main: weight: 1 pre: --- Staticcheck is a state of the art linter for the [Go programming language](https://go.dev/). Using static analysis, it finds bugs and performance issues, offers simplifications, and enforces style rules. Each of the [ {{< numchecks.inline >}} {{- $c := len $.Site.Data.checks.Checks -}} {{- sub $c (mod $c 25) -}} {{< /numchecks.inline >}}+ ]({{< relref "/docs/checks" >}}) checks has been designed to be fast, precise and useful. When Staticcheck flags code, you can be sure that it isn't wasting your time with unactionable warnings. Unlike many other linters, Staticcheck focuses on checks that produce few to no false positives. It's the ideal candidate for running in CI without risking spurious failures. Staticcheck aims to be trivial to adopt. It behaves just like the official `go` tool and requires no learning to get started with. Just run `staticcheck ./...` on your code in addition to `go vet ./...`. While checks have been designed to be useful out of the box, they still provide [configuration]({{< relref "/docs/configuration" >}}) where necessary, to fine-tune to your needs, without overwhelming you with hundreds of options. Staticcheck can be used from the command line, in CI, and even [directly from your editor](https://github.com/golang/tools/blob/master/gopls/doc/settings.md#staticcheck-bool). Staticcheck is open source and offered completely free of charge. [Sponsors]({{< relref "/sponsors" >}}) guarantee its continued development. }}"> golang-honnef-go-tools-2024.1/website/content/docs/changes.md000066400000000000000000000000721465704072200240710ustar00rootroot00000000000000--- title: Release notes manualLinkRelref: "/changes" --- golang-honnef-go-tools-2024.1/website/content/docs/checks.html000066400000000000000000000150021465704072200242640ustar00rootroot00000000000000--- title: "Checks" description: "Explanations for all checks in Staticcheck" menu: main: weight: 2 pre: --- {{< all-checks.inline >}} {{ define "category-list" }} {{ range $name := index $.p.Site.Data.checks.ByCategory $.cat }} {{ $check := index $.p.Site.Data.checks.Checks $name }} {{ $name }} {{ $check.TitleMarkdown | markdownify }} {{ end }} {{ end }} {{ define "category" }} {{ range $name := index $.p.Site.Data.checks.ByCategory .cat }} {{ $check := index $.p.Site.Data.checks.Checks $name }}

    {{ $name }} - {{ $check.TitleMarkdown | markdownify }}{{ if $check.NonDefault }} non-default{{ end }}

    {{ $check.TextMarkdown | $.p.Page.RenderString (dict "display" "block") }} {{ if $check.Before }}

    Before:

    {{ highlight $check.Before "go" "" }} {{ end }} {{ if $check.After }}

    After:

    {{ highlight $check.After "go" "" }} {{ end }}
    Available since
    {{ $check.Since }}
    {{ if $check.Options }}
    Options
      {{ range $opt := $check.Options -}}
    • {{ $opt }}
      • {{ end }}
    {{ end }}
    {{ end }} {{ end }} {{ $categoryNames := slice "SA" "SA1" "SA2" "SA3" "SA4" "SA5" "SA6" "SA9" "S" "S1" "ST" "ST1" "QF" "QF1" }} {{ $categories := dict "SA" (dict "name" "SA" "title" "staticcheck") "SA1" (dict "name" "SA1" "title" "Various misuses of the standard library") "SA2" (dict "name" "SA2" "title" "Concurrency issues") "SA3" (dict "name" "SA3" "title" "Testing issues") "SA4" (dict "name" "SA4" "title" "Code that isn't really doing anything") "SA5" (dict "name" "SA5" "title" "Correctness issues") "SA6" (dict "name" "SA6" "title" "Performance issues") "SA9" (dict "name" "SA9" "title" "Dubious code constructs that have a high probability of being wrong") "S" (dict "name" "S" "title" "simple") "S1" (dict "name" "S1" "title" "Code simplifications") "ST" (dict "name" "ST" "title" "stylecheck") "ST1" (dict "name" "ST1" "title" "Stylistic issues") "QF" (dict "name" "QF" "title" "quickfix") "QF1" (dict "name" "QF1" "title" "Quickfixes") }} {{ range $name := $categoryNames }} {{ $cat := index $categories $name }} {{ template "category-list" (dict "p" $ "cat" $cat.name) }} {{ end }}
    Check Short description
    {{ $cat.name }}{{ $cat.title }}
    {{ define "category-header" }}

    {{ .name }} – {{ .title }}

    {{ end }} {{ define "subcategory-header" }}

    {{ .name }} – {{ .title }}

    {{ end }} {{ template "category-header" (index $categories "SA") }}

    The SA category of checks, codenamed staticcheck, contains all checks that are concerned with the correctness of code.

    {{ template "subcategory-header" (index $categories "SA1") }}

    Checks in this category deal with misuses of the standard library. This tends to involve incorrect function arguments or violating other invariants laid out by the standard library's documentation.

    {{ template "category" (dict "p" $ "cat" "SA1") }} {{ template "subcategory-header" (index $categories "SA2") }}

    Checks in this category find concurrency bugs.

    {{ template "category" (dict "p" $ "cat" "SA2") }} {{ template "subcategory-header" (index $categories "SA3") }}

    Checks in this category find issues in tests and benchmarks.

    {{ template "category" (dict "p" $ "cat" "SA3") }} {{ template "subcategory-header" (index $categories "SA4") }}

    Checks in this category point out code that doesn't have any meaningful effect on a program's execution. Usually this means that the programmer thought the code would do one thing while in reality it does something else.

    {{ template "category" (dict "p" $ "cat" "SA4") }} {{ template "subcategory-header" (index $categories "SA5") }}

    Checks in this category find assorted bugs and crashes.

    {{ template "category" (dict "p" $ "cat" "SA5") }} {{ template "subcategory-header" (index $categories "SA6") }}

    Checks in this category find code that can be trivially made faster.

    {{ template "category" (dict "p" $ "cat" "SA6") }} {{ template "subcategory-header" (index $categories "SA9") }}

    Checks in this category find code that is probably wrong. Unlike checks in the other SA categories, checks in SA9 have a slight chance of reporting false positives. However, even false positives will point at code that is confusing and that should probably be refactored.

    {{ template "category" (dict "p" $ "cat" "SA9") }} {{ template "category-header" (index $categories "S") }}

    The S category of checks, codenamed simple, contains all checks that are concerned with simplifying code.

    {{ template "subcategory-header" (index $categories "S1") }}

    Checks in this category find code that is unnecessarily complex and that can be trivially simplified.

    {{ template "category" (dict "p" $ "cat" "S1") }} {{ template "category-header" (index $categories "ST") }}

    The ST category of checks, codenamed stylecheck, contains all checks that are concerned with stylistic issues.

    {{ template "subcategory-header" (index $categories "ST1") }}

    The rules contained in this category are primarily derived from the Go wiki and represent community consensus.

    Some checks are very pedantic and disabled by default. You may want to tweak which checks from this category run, based on your project's needs.

    {{ template "category" (dict "p" $ "cat" "ST1") }} {{ template "category-header" (index $categories "QF") }}

    The QF category of checks, codenamed quickfix, contains checks that are used as part of gopls for automatic refactorings. In the context of gopls, diagnostics of these checks will usually show up as hints, sometimes as information-level diagnostics.

    {{ template "subcategory-header" (index $categories "QF1") }} {{ template "category" (dict "p" $ "cat" "QF1") }} {{< /all-checks.inline >}} golang-honnef-go-tools-2024.1/website/content/docs/configuration/000077500000000000000000000000001465704072200250075ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/content/docs/configuration/_index.md000066400000000000000000000142221465704072200266000ustar00rootroot00000000000000--- title: "Configuration" description: "Tweak Staticcheck to your requirements" weight: 3 --- Staticcheck tries to provide a good out-of-the-box experience, but it also offers a number of options to fine-tune it to your specific needs. ## Command-line flags {#cli-flags} Staticcheck uses command-line flags for settings that are specific to single invocations and that may change depending on the context (local development, continuous integration etc). This includes which build tags to set and which output format to use. All of the CLI flags are explained in the [Command-line interface]({{< relref "/docs/running-staticcheck/cli" >}}) article. ## Configuration files {#configuration-files} Staticcheck uses configuration files for settings that apply to all users of Staticcheck on a given project. Configuration files can choose which checks to run as well as tweak the behavior of individual checks. Configuration files are named `staticcheck.conf` and apply to subtrees of packages. Consider the following tree of Go packages and configuration files: ```plain . ├── net │ ├── cgi │ ├── http │ │ ├── parser │ │ └── staticcheck.conf // config 3 │ └── staticcheck.conf // config 2 ├── staticcheck.conf // config 1 └── strconv ``` Config 1 will apply to all packages, config 2 will apply to `./net/...` and config 3 will apply to `./net/http/...`. When multiple configuration files apply to a package (for example, all three configs will apply to `./net/http`) they will be merged, with settings in files deeper in the package tree overriding rules higher up the tree. ### Configuration format {#configuration-format} Staticcheck configuration files are named `staticcheck.conf` and contain [TOML](https://github.com/toml-lang/toml). Any set option will override the same option from further up the package tree, whereas unset options will inherit their values. Additionally, the special value `"inherit"` can be used to inherit values. This is especially useful for array values, as it allows adding and removing values to the inherited option. For example, the option `checks = ["inherit", "ST1000"]` will inherit the enabled checks and additionally enable ST1000. The special value `"all"` matches all possible values. this is used when enabling or disabling checks. Values prefixed with a minus sign, such as `"-S1000"` will exclude values from a list. This can be used in combination with `"all"` to express "all but", or in combination with `"inherit"` to remove values from the inherited option. ### Configuration options {#configuration-options} A list of all options and their explanations can be found on the [Options]({{< relref "/docs/configuration/options" >}}) page. ### Example configuration {#example-configuration} The following example configuration is the textual representation of Staticcheck's default configuration. {{% content "default_config.md" %}} ## Ignoring problems with linter directives {#ignoring-problems} In general, you shouldn't have to ignore problems reported by Staticcheck. Great care is taken to minimize the number of false positives and subjective suggestions. Dubious code should be rewritten and genuine false positives should be reported so that they can be fixed. The reality of things, however, is that not all corner cases can be taken into consideration. Sometimes code just has to look weird enough to confuse tools, and sometimes suggestions, though well-meant, just aren't applicable. For those rare cases, there are several ways of ignoring unwanted problems. ### Line-based linter directives {#line-based-linter-directives} The most fine-grained way of ignoring reported problems is to annotate the offending lines of code with linter directives. The `//lint:ignore Check1[,Check2,...,CheckN] reason` directive ignores one or more checks on the following line of code. The `reason` is a required field that must describe why the checks should be ignored for that line of code. This field acts as documentation for other people (including future you) reading the code. Let's consider the following example, which intentionally checks that the results of two identical function calls are not equal: ```go func TestNewEqual(t *testing.T) { if errors.New("abc") == errors.New("abc") { t.Errorf(`New("abc") == New("abc")`) } } ``` {{< check "SA4000" >}} will flag this code, pointing out that the left and right side of `==` are identical – usually indicative of a typo and a bug. To silence this problem, we can use a linter directive: ```go func TestNewEqual(t *testing.T) { //lint:ignore SA4000 we want to make sure that no two results of errors.New are ever the same if errors.New("abc") == errors.New("abc") { t.Errorf(`New("abc") == New("abc")`) } } ``` ### Maintenance of linter directives {#maintenance-of-linter-directives} It is crucial to update or remove outdated linter directives when code has been changed. Staticcheck helps you with this by making unnecessary directives a problem of its own. For example, for this (admittedly contrived) snippet of code ```go //lint:ignore SA1000 we love invalid regular expressions! regexp.Compile(".+") ``` Staticcheck will report the following: ```plain tmp.go:1:2: this linter directive didn't match anything; should it be removed? ``` Checks that have been disabled via configuration files will not cause directives to be considered unnecessary. ### File-based linter directives {#file-based-linter-directives} In some cases, you may want to disable checks for an entire file. For example, code generation may leave behind a lot of unused code, as it simplifies the generation process. Instead of manually annotating every instance of unused code, the code generator can inject a single, file-wide ignore directive to ignore the problem. File-based linter directives look a lot like line-based ones: ```go //lint:file-ignore U1000 Ignore all unused code, it's generated ``` The only difference is that these comments aren't associated with any specific line of code. Conventionally, these comments should be placed near the top of the file. Unlike line-based directives, file-based ones will not be flagged for being unnecessary. golang-honnef-go-tools-2024.1/website/content/docs/configuration/options.md000066400000000000000000000037221465704072200270300ustar00rootroot00000000000000--- title: "Options" description: "Explanations for all options" aliases: - /docs/options --- ## checks {#checks} This option sets which [checks]({{< relref "/docs/checks" >}}) should be enabled. By default, most checks will be enabled, except for those that are too opinionated or that only apply to packages in certain domains. All supported checks can be enabled with `"all"`. Subsets of checks can be enabled via prefixes and the `*` glob; for example, `"S*"`, `"SA*"` and `"SA1*"` will enable all checks in the S, SA and SA1 subgroups respectively. Individual checks can be enabled by their full IDs. To disable checks, prefix them with a minus sign. This works on all of the previously mentioned values. Default value: `["all", "-{{< check "ST1000" >}}", "-{{< check "ST1003" >}}", "-{{< check "ST1016" >}}", "-{{< check "ST1020" >}}", "-{{< check "ST1021" >}}", "-{{< check "ST1022" >}}"]` ## initialisms {#initialisms} {{< check "ST1003" >}} checks, among other things, for the correct capitalization of initialisms. The set of known initialisms can be configured with this option. Default value: `["ACL", "API", "ASCII", "CPU", "CSS", "DNS", "EOF", "GUID", "HTML", "HTTP", "HTTPS", "ID", "IP", "JSON", "QPS", "RAM", "RPC", "SLA", "SMTP", "SQL", "SSH", "TCP", "TLS", "TTL", "UDP", "UI", "GID", "UID", "UUID", "URI", "URL", "UTF8", "VM", "XML", "XMPP", "XSRF", "XSS", "SIP", "RTP", "AMQP", "DB", "TS"]` ## dot_import_whitelist {#dot_import_whitelist} By default, {{< check "ST1001" >}} forbids all uses of dot imports in non-test packages. This setting allows setting a whitelist of import paths that can be dot-imported anywhere. Default value: `[]` ## http_status_code_whitelist {#http_status_code_whitelist} {{< check "ST1013" >}} recommends using constants from the `net/http` package instead of hard-coding numeric HTTP status codes. This setting specifies a list of numeric status codes that this check does not complain about. Default value: `["200", "400", "404", "500"]` golang-honnef-go-tools-2024.1/website/content/docs/faq.md000066400000000000000000000031711465704072200232330ustar00rootroot00000000000000--- title: "Frequently Asked Questions" --- {{% faq/list %}} {{% faq/question id="false-positives" question="Staticcheck is wrong, what should I do?" %}} First, make sure that Staticcheck is actually wrong. It can find very subtle bugs, and what may look like a false positive at first glance is usually a genuine bug. There is a long list of competent programmers [who got it wrong before.](https://github.com/dominikh/go-tools/issues?q=is%3Aissue+label%3Afalse-positive+label%3Ainvalid+is%3Aclosed) However, sometimes Staticcheck _is_ wrong and you want to suppress a warning to get on with your work. In that case, you can use [ignore directives to ignore specific problems]({{< relref "/docs/configuration/#ignoring-problems" >}}). You should also [report the false positive](https://github.com/dominikh/go-tools/issues/new?assignees=&labels=false-positive%2C+needs-triage&template=1_false_positive.md&title=) so that we can fix it. We don't expect users to have to ignore many problems, and we always aim to avoid false positives. Some checks, particularly those in the `ST` (stylecheck) category, may not be applicable to your code base at all. In that case, you should disable the check using the [`checks` option]({{< relref "/docs/configuration/options#checks" >}}) in your [configuration]({{< relref "/docs/configuration/#configuration-files" >}}). {{% /faq/question %}} {{% faq/question id="go-version" question="Staticcheck's suggestions don't apply to my version of Go" %}} You can [specify the version of Go your code should work with.]({{< relref "/docs/configuration/#targeting-go-versions" >}}) {{% /faq/question %}} {{% /faq/list %}} golang-honnef-go-tools-2024.1/website/content/docs/getting-started.md000066400000000000000000000046741465704072200256020ustar00rootroot00000000000000--- title: "Getting started" description: "Quickly get started using Staticcheck" weight: 1 aliases: - /docs/install --- ## Installation Beginning with Go 1.17, the simplest way of installing Staticcheck is by running `go install honnef.co/go/tools/cmd/staticcheck@latest`. This will install the latest version of Staticcheck to `$GOPATH/bin`. To find out where `$GOPATH` is, run `go env GOPATH`. Instead of `@latest`, you can also use a specific version, such as `@2020.2.1`. If you'd like to be notified of new releases, you can use [GitHub's Releases only watches](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/viewing-your-subscriptions#configuring-your-watch-settings-for-an-individual-repository). ### Binary releases We publish binary releases for the most common operating systems and CPU architectures. These can be downloaded from [GitHub](https://github.com/dominikh/go-tools/releases). ### Distribution packages Many package managers include Staticcheck, allowing you to install it with your usual commands, such as `apt install`. Note, however, that you might not always get new releases in a timely manner. What follows is a non-exhaustive list of the package names in various package repositories.
    Arch Linux : [staticcheck](https://archlinux.org/packages/extra/x86_64/staticcheck/) Debian : [go-staticcheck](https://packages.debian.org/go-staticcheck) Fedora : [golang-honnef-tools](https://fedora.pkgs.org/33/fedora-x86_64/golang-honnef-tools-2020.1.5-2.fc33.x86_64.rpm.html) Homebrew : [staticcheck](https://formulae.brew.sh/formula/staticcheck) MacPorts : [staticcheck](https://ports.macports.org/port/staticcheck/summary) NixOS : go-tools Scoop : [staticcheck](https://github.com/ScoopInstaller/Main/blob/master/bucket/staticcheck.json)
    ## Running Staticcheck The `staticcheck` command works much like `go build` or `go vet` do. It supports all of the same package patterns. For example, `staticcheck .` will check the current package, and `staticcheck ./...` will check all packages. For more details on specifying packages to check, see `go help packages`. Therefore, to start using Staticcheck, just run it on your code: `staticcheck ./...`. It will print any issues it finds, or nothing at all if your code is squeaky clean. Read the [Running Staticcheck]({{< relref "/docs/running-staticcheck" >}}) articles to learn more about running Staticcheck. golang-honnef-go-tools-2024.1/website/content/docs/running-staticcheck/000077500000000000000000000000001465704072200261035ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/content/docs/running-staticcheck/_index.md000066400000000000000000000001041465704072200276660ustar00rootroot00000000000000--- title: Running Staticcheck weight: 2 aliases: - /docs/run --- golang-honnef-go-tools-2024.1/website/content/docs/running-staticcheck/ci/000077500000000000000000000000001465704072200264765ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/content/docs/running-staticcheck/ci/_index.md000066400000000000000000000001201465704072200302570ustar00rootroot00000000000000--- title: Continuous integration description: How to run Staticcheck in CI --- golang-honnef-go-tools-2024.1/website/content/docs/running-staticcheck/ci/github-actions/000077500000000000000000000000001465704072200314165ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/content/docs/running-staticcheck/ci/github-actions/index.md000066400000000000000000000072751465704072200330620ustar00rootroot00000000000000--- title: GitHub Actions description: Running Staticcheck in GitHub Actions aliases: - /docs/running-staticcheck/github-actions --- We publish [our own action](https://github.com/marketplace/actions/staticcheck) for [GitHub Actions](https://github.com/features/actions), which makes it very simple to run Staticcheck in CI on GitHub. ## Examples At its simplest, just add `dominikh/staticcheck-action` as a step in your existing workflow. A minimal workflow might look like this: ```yaml name: "CI" on: ["push", "pull_request"] jobs: ci: name: "Run CI" runs-on: ubuntu-latest steps: - uses: actions/checkout@v1 with: fetch-depth: 1 - uses: dominikh/staticcheck-action@v1.2.0 with: version: "2022.1.1" ``` A more advanced example that runs tests, go vet and Staticcheck on multiple OSs and Go versions looks like this: ```yaml name: "CI" on: ["push", "pull_request"] jobs: ci: name: "Run CI" strategy: fail-fast: false matrix: os: ["windows-latest", "ubuntu-latest", "macOS-latest"] go: ["1.16.x", "1.17.x"] runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v1 with: fetch-depth: 1 - uses: WillAbides/setup-go-faster@v1.7.0 with: go-version: ${{ matrix.go }} - run: "go test ./..." - run: "go vet ./..." - uses: dominikh/staticcheck-action@v1.2.0 with: version: "2022.1.1" install-go: false cache-key: ${{ matrix.go }} ``` Note that this example could benefit from further improvements, such as caching of Go's build cache. ## Managing Go By default, `staticcheck-action` installs Go so that it can install and run Staticcheck. It also saves and restores Go's build cache (in addition to Staticcheck's own cache) to speed up future runs. This is intended for trivial jobs that only run Staticcheck, not other steps such as `go test`. For more complicated jobs, it is strongly recommended that you set `install-go` to `false`, install Go yourself (e.g. by using [`actions/setup-go`](https://github.com/actions/setup-go) or [`WillAbides/setup-go-faster`](https://github.com/WillAbides/setup-go-faster)), and save and restore the Go build cache, for improved performance. When installing Go, make sure the version meets Staticcheck's minimum requirements. A given Staticcheck release supports the last two versions of Go (such as Go 1.16 and Go 1.17) at the time of release. The action itself requires at least Go 1.16. ## Options ### `version` Which version of Staticcheck to use. Because new versions of Staticcheck introduce new checks that may break your build, it is recommended to pin to a specific version and to update Staticheck consciously. It defaults to `latest`, which installs the latest released version of Staticcheck. ### `min-go-version` Minimum version of Go to support. This affects the diagnostics reported by Staticcheck, avoiding suggestions that are not applicable to older versions of Go. If unset, this will default to the Go version specified in your go.mod. See https://staticcheck.dev/docs/running-staticcheck/cli/#go for more information. ### `build-tags` Go build tags that get passed to Staticcheck via the `-tags` flag. ### `install-go` Whether the action should install a suitable version of Go to install and run Staticcheck. If Staticcheck is the only action in your job, this option can usually be left on its default value of `true`. If your job already installs Go prior to running Staticcheck, for example to run unit tests, it is best to set this option to `false`. The latest release of Staticcheck works with the last two minor releases of Go. The action itself requires at least Go 1.16. ### `cache-key` String to include in the cache key, in addition to the default, which is `runner.os`. This is useful when using multiple Go versions. golang-honnef-go-tools-2024.1/website/content/docs/running-staticcheck/cli/000077500000000000000000000000001465704072200266525ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/content/docs/running-staticcheck/cli/_index.md000066400000000000000000000062271465704072200304510ustar00rootroot00000000000000--- title: Command-line interface description: How to use the `staticcheck` command --- The `staticcheck` command is the primary way of running Staticcheck. At its core, the `staticcheck` command works a lot like `go vet` or `go build`. It accepts the same package patterns (see `go help packages` for details), it outputs problems in the same format, it supports a `-tags` flag for specifying which build tags to use, and so on. Overall, it is meant to feel like another `go` command. However, it also comes with several of its own flags to support some of its unique functionality. This article will focus on explaining that unique functionality. ## Explaining checks {#explain} You can use `staticcheck -explain ` to get a helpful description of a check. Every diagnostic that staticcheck reports is annotated with the identifier of the specific check that found the issue. For example, in ```text foo.go:1248:4: unnecessary use of fmt.Sprintf (S1039) ``` the check's identifier is S1039. Running `staticcheck -explain S1039` will output the following: ```text Unnecessary use of fmt.Sprint Calling fmt.Sprint with a single string argument is unnecessary and identical to using the string directly. Available since 2020.1 Online documentation https://staticcheck.dev/docs/checks#S1039 ``` The output includes a one-line summary, one or more paragraphs of helpful text, the first version of Staticcheck that the check appeared in, and a link to online documentation, which contains the same information as the output of `staticcheck -explain`. ## Selecting an output format {#format} Staticcheck can format its output in a number of ways, by using the `-f` flag. See this [list of formatters]({{< relref "/docs/running-staticcheck/cli/formatters" >}}) for a list of all formatters. ## Targeting Go versions {#go} Some of Staticcheck's analyses adjust their behavior based on the targeted Go version. For example, the suggestion that one use `for range xs` instead of `for _ = range xs` only applies to Go 1.4 and later, as it won't compile with versions of Go older than that. By default, Staticcheck targets the Go version declared in `go.mod` via the `go` directive. For Go 1.21 and never, that directive specifies the minimum required version of Go. For older versions of Go, the directive technically specifies the maximum version of language features that the module can use, which means it might be higher than the minimum required version. In those cases, you can manually overwrite the targeted Go version by using the `-go` command line flag. For example, `staticcheck -go 1.0 ./...` will only make suggestions that work with Go 1.0. The targeted Go version limits both language features and parts of the standard library that will be recommended. ## Excluding tests {#tests} By default, Staticcheck analyses packages as well as their tests. By passing `-tests=false`, one can skip the analysis of tests. This is primarily useful for the {{< check "U1000" >}} check, as it allows finding code that is only used by tests and would otherwise be unused. golang-honnef-go-tools-2024.1/website/content/docs/running-staticcheck/cli/build-tags/000077500000000000000000000000001465704072200307055ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/content/docs/running-staticcheck/cli/build-tags/index.md000066400000000000000000000150571465704072200323460ustar00rootroot00000000000000--- title: Build tags description: How to correctly check code that uses build tags --- ## Introduction In Go, files can have build tags, which control when said files will be part of a package. For example, two files might contain alternate implementations of the same function, targeting Linux and Windows respectively. Due to this, a single import path really refers to a collection of packages, with any particular package being chosen by a combination of build tags. Even if your code doesn't make use of build tags, any of your transitive dependencies might. Therefore, running `staticcheck my/package` really only checks one variant of `my/package`. For more information on Go's build tags, see [`go help buildconstraint`](https://pkg.go.dev/cmd/go#hdr-Build_constraints). ## Implications Checking packages using a single set of build tags can lead to both false positives and false negatives. The reason for false negatives is straightforward: if some code is being excluded by build tags, then we won't check it. False positives can be a bit more involved. Consider the following package, in [txtar format](https://pkg.go.dev/golang.org/x/tools/txtar#hdr-Txtar_format): ```go -- api_linux.go -- package pkg func Entry() { foo() } -- api_windows.go -- package pkg func Entry() { bar() } -- shared.go -- package pkg func foo() {} func bar() {} ``` If we don't check the Windows build, then the function `bar` seems unused. Similarly, if we don't check the Linux build, `foo` seems unused. ```terminal $ GOOS=linux staticcheck shared.go:4:6: func bar is unused (U1000) $ GOOS=windows staticcheck shared.go:3:6: func foo is unused (U1000) ``` Only when we check both builds do we see that both functions are in fact used. Arguably, `foo` and `bar` should live in files with matching build tags to avoid this. However, in reality, code bases can be complex, and it isn't always clear which sets of build tags make use of what code. After all, if we always knew, we wouldn't have dead code to begin with. Another example involves control flow. Consider this package, again in txtar format: ```go -- api_linux.go -- package pkg func dieIfUnsupported() { panic("unsupported") } -- api_windows.go -- package pkg func dieIfUnsupported() {} -- shared.go -- package pkg func foo() {} func Entry() { dieIfUnsupported() foo() } ``` Here, `dieIfUnsupported` panics unconditionally on Linux, but not on Windows. Because Staticcheck takes control flow into consideration, this means that `foo` is unused on Linux but used on Windows. Several checks have this sort of false positive, not just U1000. ## Solution The solution to this problem is to run Staticcheck multiple times with different build tags and to merge the results. At first glance, one might think that Staticcheck should be able to do this fully automatically: look at all build tags, find all unique combinations, and check them all. However, this doesn't scale. To be correct, Staticcheck would have to take dependencies and their tags into consideration, too. Virtually all code depends on the Go standard library, and the Go standard library supports a plethora of operating systems, architectures, and a number of tags such as `netgo`. All in all, there are thousands of unique combinations. Checking all of these would take far too long. However, the number of build configurations you care about is probably much smaller. Your software probably supports 2-3 operating systems on 1-2 architectures, and maybe has a debug and a release build. This makes for a lot fewer combinations that need to be checked. These are probably the same combinations you're already checking in CI, too, by running their tests. This will become useful in a bit. ### The `-merge` flag Using the `-merge` flag, Staticcheck can merge the results of multiple runs. It decides on a per-check basis whether any run or all runs have to have reported an issue for it to be valid. It also takes into consideration which files were checked by which run, to reduce false negatives. In order to use `-merge`, the runs to be merged have to use the `-f binary` flag. This outputs results in a binary format containing all information required by `-merge`. When using `-merge`, arguments are interpreted as file names instead of import paths, so that `staticcheck -merge file1 file2` will read the files `file1` and `file2`, which must contain the output of `staticcheck -f binary` runs, and merge them. ```terminal $ GOOS=linux staticcheck -f binary >file1 $ GOOS=windows staticcheck -f binary >file2 $ staticcheck -merge file1 file2 ... ``` Alternatively, if no arguments are passed, `staticcheck -merge` will read from standard input instead. This allows for workflows like ``` ( GOOS=linux staticcheck -f binary GOOS=windows staticcheck -f binary ) | staticcheck -merge ``` This multi-step workflow of generating per-run output and merging it makes it possible to run Staticcheck on different systems before merging the results, which might be especially required when using cgo. ### The `-matrix` flag With the `-matrix` flag, you can instruct Staticcheck to check multiple build configurations at once and merge the results. In other words, it automates running Staticcheck multiple times and merging results afterwards. This is useful when all configurations can be checked on a single system, for example because you don't use cgo. When using the `-matrix` flag, Staticcheck reads a build matrix from standard input. The build matrix uses a line-based format, where each non-empty line specifies a build name, environment variables and command-line flags. A line is of the format `: [environment variables] [flags]`, for example `linux_debug: GOOS=linux -tags=debug -some-flag="some value"`. Environment variables and flags get passed to `go` when Staticcheck analyzes code, so you can use all flags that `go` supports, such as `-tags` or `-gcflags`, although few flags other than `-tags` are really useful. Valid build names consist of letters, numbers and underscores. Here is an example of using a build matrix: ```terminal $ staticcheck -matrix < --- {{< blocks/section type="section" color="white" >}} # Supporting Staticcheck's open source development Staticcheck is an open source project that is provided free of charge and without any expectations. Nevertheless, working on it requires a considerable time investment. Some very generous people choose to support its development by donating money on [GitHub Sponsors](https://github.com/users/dominikh/sponsorship) or [Patreon](https://www.patreon.com/dominikh). While this is in no way expected of them, it is tremendously appreciated. In addition to these individuals, a number of companies also decide to support Staticcheck through monetary means. Their contributions to open source ensure the viability and future development of Staticcheck. Their support, too, is greatly appreciated. {{< sponsors.inline >}} {{ with $sponsors := $.Site.Data.sponsors.sponsors }} The companies supporting Staticcheck are, in alphabetical order:
      {{ range $sponsor := sort $sponsors "name" "asc" }} {{ if $sponsor.enabled }}
    • {{ $sponsor.name }}
      • {{ end }} {{ end }}
    {{ end }} {{< /sponsors.inline >}} If your company would like to support Staticcheck, please check out [GitHub Sponsors](https://github.com/users/dominikh/sponsorship) or [get in touch with me directly.](mailto:dominik@honnef.co) For [$250 USD a month](https://github.com/users/dominikh/sponsorship?utf8=%E2%9C%93&tier_id=MDIyOk1hcmtldHBsYWNlTGlzdGluZ1BsYW4yNTAy&editing=false), we will proudly display your logo on the project's homepage, showing the world that you truly care about code quality and open source. Finally, every single user, individual and company alike, is to be thanked for using Staticcheck, providing feedback, requesting features and in general caring about code quality. Without its users, there would be no Staticcheck. {{< /blocks/section >}} golang-honnef-go-tools-2024.1/website/go.mod000066400000000000000000000007001465704072200206410ustar00rootroot00000000000000module honnef.co/go/tools/website go 1.22.1 replace honnef.co/go/tools => ../ require ( github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c honnef.co/go/tools v0.0.0-00010101000000-000000000000 ) require ( golang.org/x/exp/typeparams v0.0.0-20231108232855-2478ac86f678 // indirect golang.org/x/mod v0.17.0 // indirect golang.org/x/sync v0.7.0 // indirect golang.org/x/tools v0.21.1-0.20240531212143-b6235391adb3 // indirect ) golang-honnef-go-tools-2024.1/website/go.sum000066400000000000000000000017271465704072200207000ustar00rootroot00000000000000github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c h1:pxW6RcqyfI9/kWtOwnv/G+AzdKuy2ZrqINhenH4HyNs= github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho= golang.org/x/exp/typeparams v0.0.0-20231108232855-2478ac86f678 h1:1P7xPZEwZMoBoz0Yze5Nx2/4pxj6nw9ZqHWXqP0iRgQ= golang.org/x/exp/typeparams v0.0.0-20231108232855-2478ac86f678/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk= golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA= golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M= golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/tools v0.21.1-0.20240531212143-b6235391adb3 h1:SHq4Rl+B7WvyM4XODon1LXtP7gcG49+7Jubt1gWWswY= golang.org/x/tools v0.21.1-0.20240531212143-b6235391adb3/go.mod h1:bqv7PJ/TtlrzgJKhOAGdDUkUltQapRik/UEHubLVBWo= golang-honnef-go-tools-2024.1/website/layouts/000077500000000000000000000000001465704072200212365ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/layouts/_internal/000077500000000000000000000000001465704072200232115ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/layouts/_internal/twitter_cards.html000066400000000000000000000023231465704072200267550ustar00rootroot00000000000000 {{- with $.Params.images -}} {{ else -}} {{- $images := $.Resources.ByType "image" -}} {{- $featured := $images.GetMatch "*feature*" -}} {{- if not $featured }}{{ $featured = $images.GetMatch "{*cover*,*thumbnail*}" }}{{ end -}} {{- with $featured -}} {{- else -}} {{- with $.Site.Params.images -}} {{- end -}} {{- end -}} {{- end }} {{ with .Site.Social.twitter -}} {{ end -}} golang-honnef-go-tools-2024.1/website/layouts/changes/000077500000000000000000000000001465704072200226465ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/layouts/changes/list.rss.xml000066400000000000000000000043141465704072200251530ustar00rootroot00000000000000 {{ .Site.Title }} – {{ .Title }} {{ .Permalink }} Recent content {{ if ne .Title .Site.Title }}{{ with .Title }}in {{.}} {{ end }}{{ end }}on {{ .Site.Title }} Hugo -- gohugo.io {{ with .Site.LanguageCode }} {{.}} {{end}} {{ with .Site.Author.email }} {{.}}{{ with $.Site.Author.name }} ({{.}}){{end}} {{end}} {{ with .Site.Author.email }} {{.}}{{ with $.Site.Author.name }} ({{.}}){{end}} {{end}} {{ with .Site.Copyright }} {{.}} {{end}} {{ if not .Date.IsZero }} {{ .Date.Format "Mon, 02 Jan 2006 15:04:05 -0700" | safeHTML }} {{ end }} {{ with .OutputFormats.Get "RSS" }} {{ printf "" .Permalink .MediaType | safeHTML }} {{ end }} {{ if not $.Section }} {{ $sections := .Site.Params.rss_sections | default (slice "blog") }} {{ .Scratch.Set "rss_pages" (first 50 (where $.Site.RegularPages "Type" "in" $sections )) }} {{ else }} {{ .Scratch.Set "rss_pages" (first 50 $.Pages) }} {{ end }} {{ range (.Scratch.Get "rss_pages") }} {{ $.Page.Title }}: {{ .Title }} {{ .Permalink }} {{ if not .Date.IsZero }} {{ .Date.Format "Mon, 02 Jan 2006 15:04:05 -0700" }} {{ end }} {{ with .Site.Author.email }} {{.}}{{ with $.Site.Author.name }} ({{.}}){{end}} {{end}} {{ .Permalink }} {{ .Content | html }} {{ end }} golang-honnef-go-tools-2024.1/website/layouts/index.redir000066400000000000000000000010011465704072200233640ustar00rootroot00000000000000{{ range $p := .Site.Pages }} {{- range .Aliases -}} {{ . }} {{ $p.RelPermalink }} {{ end }} {{- end -}} /pricing /sponsors 301 /docs/staticcheck -> /docs/checks 301 /docs/gosimple /docs/checks 301 /issues/* https://github.com/dominikh/go-tools/issues/:splat 301 http://staticcheck.io/* https://staticcheck.dev/:splat 301! https://staticcheck.io/* https://staticcheck.dev/:splat 301! http://www.staticcheck.io/* https://staticcheck.dev/:splat 301! https://www.staticcheck.io/* https://staticcheck.dev/:splat 301! golang-honnef-go-tools-2024.1/website/layouts/partials/000077500000000000000000000000001465704072200230555ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/layouts/partials/breadcrumb.html000066400000000000000000000035401465704072200260530ustar00rootroot00000000000000 {{ $isSingle := true -}} {{ with .Parent -}} {{ $isSingle = .IsHome -}} {{ end -}} {{ .Scratch.Set "breadcrumbMaxDepth" 0 }} {{ template "breadcrumbcount" (dict "p1" . "scratch" .Scratch) }} {{ define "breadcrumbcount" }} {{ .scratch.Set "breadcrumbMaxDepth" (add 1 (.scratch.Get "breadcrumbMaxDepth")) }} {{ if .p1.Parent }} {{ if not .p1.Parent.IsHome }} {{ template "breadcrumbcount" (dict "p1" .p1.Parent "scratch" .scratch) }} {{ end }} {{ else if not .IsHome }} {{ template "breadcrumbcount" (dict "p1" .p1.Site.Home "scratch" .scratch) }} {{ end }} {{ end }} {{- define "breadcrumbnav" -}} {{ if .p1.Parent -}} {{ if not .p1.Parent.IsHome -}} {{ template "breadcrumbnav" (dict "p1" .p1.Parent "p2" .p2 "depth" (add .depth 1) "scratch" .scratch) -}} {{ end -}} {{ else if not .p1.IsHome -}} {{ template "breadcrumbnav" (dict "p1" .p1.Site.Home "p2" .p2 "depth" (add .depth 1) "scratch" .scratch) -}} {{ end -}} {{ $isActive := eq .p1 .p2 }}
  • {{- .p1.LinkTitle -}}
    • {{- end -}} golang-honnef-go-tools-2024.1/website/layouts/partials/footer.html000066400000000000000000000060561465704072200252500ustar00rootroot00000000000000 {{ define "partials/sponsor-logo-resize" }} {{- if gt .img.Width .width -}} {{- $rimg := .img.Resize (printf "%dx" .width) -}} {{- $rimg.RelPermalink }} {{ $rimg.Width -}}w, {{- end -}} {{ end }} {{ define "partials/sponsor-logo" }} {{ $img := resources.Get .logo }} {{ end }} {{ with $sponsors := $.Site.Data.sponsors.sponsors }}

    Sponsors

    {{ range $sponsor := sort $sponsors "name" "asc" }} {{ if $sponsor.enabled }} {{ partial "sponsor-logo" (dict "name" $sponsor.name "url" $sponsor.url "logo" $sponsor.logo) }} {{ end }} {{ end }}
    {{ end }} {{ $links := .Site.Params.links }}
    {{ range $cp := .Site.Data.copyrights.copyrights }} {{ $cp | safeHTML }}
    {{ end }} {{ with .Site.Params.privacy_policy }}{{ T "footer_privacy_policy" }}{{ end }} {{ if not .Site.Params.ui.footer_about_disable }} {{ with .Site.GetPage "about" }}

    {{ .Title }}

    {{ end }} {{ end }}
    {{ define "footer-links-block" }}
      {{ range . }}
      • {{ end }}
    {{ end }} golang-honnef-go-tools-2024.1/website/layouts/partials/hooks/000077500000000000000000000000001465704072200242005ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/layouts/partials/hooks/head-end.html000066400000000000000000000012211465704072200265270ustar00rootroot00000000000000 golang-honnef-go-tools-2024.1/website/layouts/partials/navbar.html000066400000000000000000000036041465704072200252170ustar00rootroot00000000000000 {{ $cover := and (.HasShortcode "blocks/cover") (not .Site.Params.ui.navbar_translucent_over_cover_disable) }} golang-honnef-go-tools-2024.1/website/layouts/shortcodes/000077500000000000000000000000001465704072200234135ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/layouts/shortcodes/check.html000066400000000000000000000003061465704072200253550ustar00rootroot00000000000000{{ $name := .Get 0 -}} {{ $check := index $.Site.Data.checks.Checks $name -}} {{ with .Get 0 }}{{$name}}{{ end -}} golang-honnef-go-tools-2024.1/website/layouts/shortcodes/commit.html000066400000000000000000000001741465704072200255730ustar00rootroot00000000000000{{ with .Get 0 }}{{ . }}{{ end -}} golang-honnef-go-tools-2024.1/website/layouts/shortcodes/content.html000066400000000000000000000001301465704072200257450ustar00rootroot00000000000000{{$file := .Get 0}} {{ with .Site.GetPage $file }}{{ .Content | markdownify }}{{ end }} golang-honnef-go-tools-2024.1/website/layouts/shortcodes/details.html000066400000000000000000000001241465704072200257230ustar00rootroot00000000000000
    {{ .Get 0 }} {{ .Inner | markdownify }}
    golang-honnef-go-tools-2024.1/website/layouts/shortcodes/faq/000077500000000000000000000000001465704072200241625ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/layouts/shortcodes/faq/list.html000066400000000000000000000001141465704072200260170ustar00rootroot00000000000000
    {{ .Inner }}
    golang-honnef-go-tools-2024.1/website/layouts/shortcodes/faq/question.md000066400000000000000000000004371465704072200263570ustar00rootroot00000000000000
    ## {{ .Get "question" }} {#{{ .Get "id" }}}
    {{ .Inner }}
    golang-honnef-go-tools-2024.1/website/layouts/shortcodes/issue.html000066400000000000000000000001641465704072200254320ustar00rootroot00000000000000{{ with .Get 0 }}issue {{ . }}{{ end -}} golang-honnef-go-tools-2024.1/website/layouts/shortcodes/issueref.html000066400000000000000000000000541465704072200261250ustar00rootroot00000000000000https://staticcheck.dev/issues/{{ .Get 0 }} golang-honnef-go-tools-2024.1/website/layouts/shortcodes/option.html000066400000000000000000000001321465704072200256050ustar00rootroot00000000000000{{ .Get 0 }}{{"" -}} golang-honnef-go-tools-2024.1/website/package-lock.json000066400000000000000000001537071465704072200227670ustar00rootroot00000000000000{ "name": "website", "lockfileVersion": 2, "requires": true, "packages": { "": { "dependencies": { "autoprefixer": "^10.4.13", "postcss": "^8.4.31", "postcss-cli": "^10.1.0" } }, "node_modules/@nodelib/fs.scandir": { "version": "2.1.5", "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" }, "engines": { "node": ">= 8" } }, "node_modules/@nodelib/fs.stat": { "version": "2.0.5", "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", "engines": { "node": ">= 8" } }, "node_modules/@nodelib/fs.walk": { "version": "1.2.8", "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" }, "engines": { "node": ">= 8" } }, "node_modules/ansi-regex": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", "engines": { "node": ">=8" } }, "node_modules/ansi-styles": { "version": "4.3.0", "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dependencies": { "color-convert": "^2.0.1" }, "engines": { "node": ">=8" }, "funding": { "url": "https://github.com/chalk/ansi-styles?sponsor=1" } }, "node_modules/anymatch": { "version": "3.1.3", "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", "dependencies": { "normalize-path": "^3.0.0", "picomatch": "^2.0.4" }, "engines": { "node": ">= 8" } }, "node_modules/autoprefixer": { "version": "10.4.13", "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.13.tgz", "integrity": "sha512-49vKpMqcZYsJjwotvt4+h/BCjJVnhGwcLpDt5xkcaOG3eLrG/HUYLagrihYsQ+qrIBgIzX1Rw7a6L8I/ZA1Atg==", "funding": [ { "type": "opencollective", "url": "https://opencollective.com/postcss/" }, { "type": "tidelift", "url": "https://tidelift.com/funding/github/npm/autoprefixer" } ], "dependencies": { "browserslist": "^4.21.4", "caniuse-lite": "^1.0.30001426", "fraction.js": "^4.2.0", "normalize-range": "^0.1.2", "picocolors": "^1.0.0", "postcss-value-parser": "^4.2.0" }, "bin": { "autoprefixer": "bin/autoprefixer" }, "engines": { "node": "^10 || ^12 || >=14" }, "peerDependencies": { "postcss": "^8.1.0" } }, "node_modules/binary-extensions": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==", "engines": { "node": ">=8" } }, "node_modules/braces": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", "dependencies": { "fill-range": "^7.0.1" }, "engines": { "node": ">=8" } }, "node_modules/browserslist": { "version": "4.21.5", "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.5.tgz", "integrity": "sha512-tUkiguQGW7S3IhB7N+c2MV/HZPSCPAAiYBZXLsBhFB/PCy6ZKKsZrmBayHV9fdGV/ARIfJ14NkxKzRDjvp7L6w==", "funding": [ { "type": "opencollective", "url": "https://opencollective.com/browserslist" }, { "type": "tidelift", "url": "https://tidelift.com/funding/github/npm/browserslist" } ], "dependencies": { "caniuse-lite": "^1.0.30001449", "electron-to-chromium": "^1.4.284", "node-releases": "^2.0.8", "update-browserslist-db": "^1.0.10" }, "bin": { "browserslist": "cli.js" }, "engines": { "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" } }, "node_modules/caniuse-lite": { "version": "1.0.30001450", "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001450.tgz", "integrity": "sha512-qMBmvmQmFXaSxexkjjfMvD5rnDL0+m+dUMZKoDYsGG8iZN29RuYh9eRoMvKsT6uMAWlyUUGDEQGJJYjzCIO9ew==", "funding": [ { "type": "opencollective", "url": "https://opencollective.com/browserslist" }, { "type": "tidelift", "url": "https://tidelift.com/funding/github/npm/caniuse-lite" } ] }, "node_modules/chokidar": { "version": "3.5.3", "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz", "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==", "funding": [ { "type": "individual", "url": "https://paulmillr.com/funding/" } ], "dependencies": { "anymatch": "~3.1.2", "braces": "~3.0.2", "glob-parent": "~5.1.2", "is-binary-path": "~2.1.0", "is-glob": "~4.0.1", "normalize-path": "~3.0.0", "readdirp": "~3.6.0" }, "engines": { "node": ">= 8.10.0" }, "optionalDependencies": { "fsevents": "~2.3.2" } }, "node_modules/cliui": { "version": "8.0.1", "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==", "dependencies": { "string-width": "^4.2.0", "strip-ansi": "^6.0.1", "wrap-ansi": "^7.0.0" }, "engines": { "node": ">=12" } }, "node_modules/color-convert": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", "dependencies": { "color-name": "~1.1.4" }, "engines": { "node": ">=7.0.0" } }, "node_modules/color-name": { "version": "1.1.4", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" }, "node_modules/dependency-graph": { "version": "0.11.0", "resolved": "https://registry.npmjs.org/dependency-graph/-/dependency-graph-0.11.0.tgz", "integrity": "sha512-JeMq7fEshyepOWDfcfHK06N3MhyPhz++vtqWhMT5O9A3K42rdsEDpfdVqjaqaAhsw6a+ZqeDvQVtD0hFHQWrzg==", "engines": { "node": ">= 0.6.0" } }, "node_modules/dir-glob": { "version": "3.0.1", "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", "dependencies": { "path-type": "^4.0.0" }, "engines": { "node": ">=8" } }, "node_modules/electron-to-chromium": { "version": "1.4.284", "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.284.tgz", "integrity": "sha512-M8WEXFuKXMYMVr45fo8mq0wUrrJHheiKZf6BArTKk9ZBYCKJEOU5H8cdWgDT+qCVZf7Na4lVUaZsA+h6uA9+PA==" }, "node_modules/emoji-regex": { "version": "8.0.0", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==" }, "node_modules/escalade": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", "engines": { "node": ">=6" } }, "node_modules/fast-glob": { "version": "3.2.12", "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.12.tgz", "integrity": "sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w==", "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", "glob-parent": "^5.1.2", "merge2": "^1.3.0", "micromatch": "^4.0.4" }, "engines": { "node": ">=8.6.0" } }, "node_modules/fastq": { "version": "1.15.0", "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz", "integrity": "sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==", "dependencies": { "reusify": "^1.0.4" } }, "node_modules/fill-range": { "version": "7.0.1", "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", "dependencies": { "to-regex-range": "^5.0.1" }, "engines": { "node": ">=8" } }, "node_modules/fraction.js": { "version": "4.2.0", "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.2.0.tgz", "integrity": "sha512-MhLuK+2gUcnZe8ZHlaaINnQLl0xRIGRfcGk2yl8xoQAfHrSsL3rYu6FCmBdkdbhc9EPlwyGHewaRsvwRMJtAlA==", "engines": { "node": "*" }, "funding": { "type": "patreon", "url": "https://www.patreon.com/infusion" } }, "node_modules/fs-extra": { "version": "11.1.0", "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.0.tgz", "integrity": "sha512-0rcTq621PD5jM/e0a3EJoGC/1TC5ZBCERW82LQuwfGnCa1V8w7dpYH1yNu+SLb6E5dkeCBzKEyLGlFrnr+dUyw==", "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" }, "engines": { "node": ">=14.14" } }, "node_modules/fsevents": { "version": "2.3.2", "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", "hasInstallScript": true, "optional": true, "os": [ "darwin" ], "engines": { "node": "^8.16.0 || ^10.6.0 || >=11.0.0" } }, "node_modules/get-caller-file": { "version": "2.0.5", "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", "engines": { "node": "6.* || 8.* || >= 10.*" } }, "node_modules/get-stdin": { "version": "9.0.0", "resolved": "https://registry.npmjs.org/get-stdin/-/get-stdin-9.0.0.tgz", "integrity": "sha512-dVKBjfWisLAicarI2Sf+JuBE/DghV4UzNAVe9yhEJuzeREd3JhOTE9cUaJTeSa77fsbQUK3pcOpJfM59+VKZaA==", "engines": { "node": ">=12" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/glob-parent": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", "dependencies": { "is-glob": "^4.0.1" }, "engines": { "node": ">= 6" } }, "node_modules/globby": { "version": "13.1.3", "resolved": "https://registry.npmjs.org/globby/-/globby-13.1.3.tgz", "integrity": "sha512-8krCNHXvlCgHDpegPzleMq07yMYTO2sXKASmZmquEYWEmCx6J5UTRbp5RwMJkTJGtcQ44YpiUYUiN0b9mzy8Bw==", "dependencies": { "dir-glob": "^3.0.1", "fast-glob": "^3.2.11", "ignore": "^5.2.0", "merge2": "^1.4.1", "slash": "^4.0.0" }, "engines": { "node": "^12.20.0 || ^14.13.1 || >=16.0.0" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/globby/node_modules/slash": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/slash/-/slash-4.0.0.tgz", "integrity": "sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew==", "engines": { "node": ">=12" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/graceful-fs": { "version": "4.2.10", "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz", "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==" }, "node_modules/ignore": { "version": "5.2.4", "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz", "integrity": "sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==", "engines": { "node": ">= 4" } }, "node_modules/is-binary-path": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", "dependencies": { "binary-extensions": "^2.0.0" }, "engines": { "node": ">=8" } }, "node_modules/is-extglob": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", "engines": { "node": ">=0.10.0" } }, "node_modules/is-fullwidth-code-point": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", "engines": { "node": ">=8" } }, "node_modules/is-glob": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", "dependencies": { "is-extglob": "^2.1.1" }, "engines": { "node": ">=0.10.0" } }, "node_modules/is-number": { "version": "7.0.0", "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", "engines": { "node": ">=0.12.0" } }, "node_modules/jsonfile": { "version": "6.1.0", "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz", "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==", "dependencies": { "universalify": "^2.0.0" }, "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "node_modules/lilconfig": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.0.6.tgz", "integrity": "sha512-9JROoBW7pobfsx+Sq2JsASvCo6Pfo6WWoUW79HuB1BCoBXD4PLWJPqDF6fNj67pqBYTbAHkE57M1kS/+L1neOg==", "engines": { "node": ">=10" } }, "node_modules/merge2": { "version": "1.4.1", "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", "engines": { "node": ">= 8" } }, "node_modules/micromatch": { "version": "4.0.5", "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", "dependencies": { "braces": "^3.0.2", "picomatch": "^2.3.1" }, "engines": { "node": ">=8.6" } }, "node_modules/nanoid": { "version": "3.3.6", "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.6.tgz", "integrity": "sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==", "funding": [ { "type": "github", "url": "https://github.com/sponsors/ai" } ], "bin": { "nanoid": "bin/nanoid.cjs" }, "engines": { "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" } }, "node_modules/node-releases": { "version": "2.0.9", "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.9.tgz", "integrity": "sha512-2xfmOrRkGogbTK9R6Leda0DGiXeY3p2NJpy4+gNCffdUvV6mdEJnaDEic1i3Ec2djAo8jWYoJMR5PB0MSMpxUA==" }, "node_modules/normalize-path": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", "engines": { "node": ">=0.10.0" } }, "node_modules/normalize-range": { "version": "0.1.2", "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz", "integrity": "sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==", "engines": { "node": ">=0.10.0" } }, "node_modules/path-type": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", "engines": { "node": ">=8" } }, "node_modules/picocolors": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz", "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==" }, "node_modules/picomatch": { "version": "2.3.1", "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", "engines": { "node": ">=8.6" }, "funding": { "url": "https://github.com/sponsors/jonschlinkert" } }, "node_modules/pify": { "version": "2.3.0", "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==", "engines": { "node": ">=0.10.0" } }, "node_modules/postcss": { "version": "8.4.31", "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.31.tgz", "integrity": "sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==", "funding": [ { "type": "opencollective", "url": "https://opencollective.com/postcss/" }, { "type": "tidelift", "url": "https://tidelift.com/funding/github/npm/postcss" }, { "type": "github", "url": "https://github.com/sponsors/ai" } ], "dependencies": { "nanoid": "^3.3.6", "picocolors": "^1.0.0", "source-map-js": "^1.0.2" }, "engines": { "node": "^10 || ^12 || >=14" } }, "node_modules/postcss-cli": { "version": "10.1.0", "resolved": "https://registry.npmjs.org/postcss-cli/-/postcss-cli-10.1.0.tgz", "integrity": "sha512-Zu7PLORkE9YwNdvOeOVKPmWghprOtjFQU3srMUGbdz3pHJiFh7yZ4geiZFMkjMfB0mtTFR3h8RemR62rPkbOPA==", "dependencies": { "chokidar": "^3.3.0", "dependency-graph": "^0.11.0", "fs-extra": "^11.0.0", "get-stdin": "^9.0.0", "globby": "^13.0.0", "picocolors": "^1.0.0", "postcss-load-config": "^4.0.0", "postcss-reporter": "^7.0.0", "pretty-hrtime": "^1.0.3", "read-cache": "^1.0.0", "slash": "^5.0.0", "yargs": "^17.0.0" }, "bin": { "postcss": "index.js" }, "engines": { "node": ">=14" }, "peerDependencies": { "postcss": "^8.0.0" } }, "node_modules/postcss-load-config": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-4.0.1.tgz", "integrity": "sha512-vEJIc8RdiBRu3oRAI0ymerOn+7rPuMvRXslTvZUKZonDHFIczxztIyJ1urxM1x9JXEikvpWWTUUqal5j/8QgvA==", "dependencies": { "lilconfig": "^2.0.5", "yaml": "^2.1.1" }, "engines": { "node": ">= 14" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/postcss/" }, "peerDependencies": { "postcss": ">=8.0.9", "ts-node": ">=9.0.0" }, "peerDependenciesMeta": { "postcss": { "optional": true }, "ts-node": { "optional": true } } }, "node_modules/postcss-reporter": { "version": "7.0.5", "resolved": "https://registry.npmjs.org/postcss-reporter/-/postcss-reporter-7.0.5.tgz", "integrity": "sha512-glWg7VZBilooZGOFPhN9msJ3FQs19Hie7l5a/eE6WglzYqVeH3ong3ShFcp9kDWJT1g2Y/wd59cocf9XxBtkWA==", "dependencies": { "picocolors": "^1.0.0", "thenby": "^1.3.4" }, "engines": { "node": ">=10" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/postcss/" }, "peerDependencies": { "postcss": "^8.1.0" } }, "node_modules/postcss-value-parser": { "version": "4.2.0", "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz", "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==" }, "node_modules/pretty-hrtime": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz", "integrity": "sha512-66hKPCr+72mlfiSjlEB1+45IjXSqvVAIy6mocupoww4tBFE9R9IhwwUGoI4G++Tc9Aq+2rxOt0RFU6gPcrte0A==", "engines": { "node": ">= 0.8" } }, "node_modules/queue-microtask": { "version": "1.2.3", "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", "funding": [ { "type": "github", "url": "https://github.com/sponsors/feross" }, { "type": "patreon", "url": "https://www.patreon.com/feross" }, { "type": "consulting", "url": "https://feross.org/support" } ] }, "node_modules/read-cache": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz", "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==", "dependencies": { "pify": "^2.3.0" } }, "node_modules/readdirp": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", "dependencies": { "picomatch": "^2.2.1" }, "engines": { "node": ">=8.10.0" } }, "node_modules/require-directory": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", "engines": { "node": ">=0.10.0" } }, "node_modules/reusify": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==", "engines": { "iojs": ">=1.0.0", "node": ">=0.10.0" } }, "node_modules/run-parallel": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", "funding": [ { "type": "github", "url": "https://github.com/sponsors/feross" }, { "type": "patreon", "url": "https://www.patreon.com/feross" }, { "type": "consulting", "url": "https://feross.org/support" } ], "dependencies": { "queue-microtask": "^1.2.2" } }, "node_modules/slash": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/slash/-/slash-5.0.0.tgz", "integrity": "sha512-n6KkmvKS0623igEVj3FF0OZs1gYYJ0o0Hj939yc1fyxl2xt+xYpLnzJB6xBSqOfV9ZFLEWodBBN/heZJahuIJQ==", "engines": { "node": ">=14.16" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/source-map-js": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.0.2.tgz", "integrity": "sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==", "engines": { "node": ">=0.10.0" } }, "node_modules/string-width": { "version": "4.2.3", "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" }, "engines": { "node": ">=8" } }, "node_modules/strip-ansi": { "version": "6.0.1", "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", "dependencies": { "ansi-regex": "^5.0.1" }, "engines": { "node": ">=8" } }, "node_modules/thenby": { "version": "1.3.4", "resolved": "https://registry.npmjs.org/thenby/-/thenby-1.3.4.tgz", "integrity": "sha512-89Gi5raiWA3QZ4b2ePcEwswC3me9JIg+ToSgtE0JWeCynLnLxNr/f9G+xfo9K+Oj4AFdom8YNJjibIARTJmapQ==" }, "node_modules/to-regex-range": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", "dependencies": { "is-number": "^7.0.0" }, "engines": { "node": ">=8.0" } }, "node_modules/universalify": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz", "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==", "engines": { "node": ">= 10.0.0" } }, "node_modules/update-browserslist-db": { "version": "1.0.10", "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.10.tgz", "integrity": "sha512-OztqDenkfFkbSG+tRxBeAnCVPckDBcvibKd35yDONx6OU8N7sqgwc7rCbkJ/WcYtVRZ4ba68d6byhC21GFh7sQ==", "funding": [ { "type": "opencollective", "url": "https://opencollective.com/browserslist" }, { "type": "tidelift", "url": "https://tidelift.com/funding/github/npm/browserslist" } ], "dependencies": { "escalade": "^3.1.1", "picocolors": "^1.0.0" }, "bin": { "browserslist-lint": "cli.js" }, "peerDependencies": { "browserslist": ">= 4.21.0" } }, "node_modules/wrap-ansi": { "version": "7.0.0", "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" }, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/chalk/wrap-ansi?sponsor=1" } }, "node_modules/y18n": { "version": "5.0.8", "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", "engines": { "node": ">=10" } }, "node_modules/yaml": { "version": "2.3.4", "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.3.4.tgz", "integrity": "sha512-8aAvwVUSHpfEqTQ4w/KMlf3HcRdt50E5ODIQJBw1fQ5RL34xabzxtUlzTXVqc4rkZsPbvrXKWnABCD7kWSmocA==", "engines": { "node": ">= 14" } }, "node_modules/yargs": { "version": "17.6.2", "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.6.2.tgz", "integrity": "sha512-1/9UrdHjDZc0eOU0HxOHoS78C69UD3JRMvzlJ7S79S2nTaWRA/whGCTV8o9e/N/1Va9YIV7Q4sOxD8VV4pCWOw==", "dependencies": { "cliui": "^8.0.1", "escalade": "^3.1.1", "get-caller-file": "^2.0.5", "require-directory": "^2.1.1", "string-width": "^4.2.3", "y18n": "^5.0.5", "yargs-parser": "^21.1.1" }, "engines": { "node": ">=12" } }, "node_modules/yargs-parser": { "version": "21.1.1", "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", "engines": { "node": ">=12" } } }, "dependencies": { "@nodelib/fs.scandir": { "version": "2.1.5", "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", "requires": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" } }, "@nodelib/fs.stat": { "version": "2.0.5", "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==" }, "@nodelib/fs.walk": { "version": "1.2.8", "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", "requires": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" } }, "ansi-regex": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==" }, "ansi-styles": { "version": "4.3.0", "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "requires": { "color-convert": "^2.0.1" } }, "anymatch": { "version": "3.1.3", "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", "requires": { "normalize-path": "^3.0.0", "picomatch": "^2.0.4" } }, "autoprefixer": { "version": "10.4.13", "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.13.tgz", "integrity": "sha512-49vKpMqcZYsJjwotvt4+h/BCjJVnhGwcLpDt5xkcaOG3eLrG/HUYLagrihYsQ+qrIBgIzX1Rw7a6L8I/ZA1Atg==", "requires": { "browserslist": "^4.21.4", "caniuse-lite": "^1.0.30001426", "fraction.js": "^4.2.0", "normalize-range": "^0.1.2", "picocolors": "^1.0.0", "postcss-value-parser": "^4.2.0" } }, "binary-extensions": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==" }, "braces": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", "requires": { "fill-range": "^7.0.1" } }, "browserslist": { "version": "4.21.5", "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.5.tgz", "integrity": "sha512-tUkiguQGW7S3IhB7N+c2MV/HZPSCPAAiYBZXLsBhFB/PCy6ZKKsZrmBayHV9fdGV/ARIfJ14NkxKzRDjvp7L6w==", "requires": { "caniuse-lite": "^1.0.30001449", "electron-to-chromium": "^1.4.284", "node-releases": "^2.0.8", "update-browserslist-db": "^1.0.10" } }, "caniuse-lite": { "version": "1.0.30001450", "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001450.tgz", "integrity": "sha512-qMBmvmQmFXaSxexkjjfMvD5rnDL0+m+dUMZKoDYsGG8iZN29RuYh9eRoMvKsT6uMAWlyUUGDEQGJJYjzCIO9ew==" }, "chokidar": { "version": "3.5.3", "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz", "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==", "requires": { "anymatch": "~3.1.2", "braces": "~3.0.2", "fsevents": "~2.3.2", "glob-parent": "~5.1.2", "is-binary-path": "~2.1.0", "is-glob": "~4.0.1", "normalize-path": "~3.0.0", "readdirp": "~3.6.0" } }, "cliui": { "version": "8.0.1", "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==", "requires": { "string-width": "^4.2.0", "strip-ansi": "^6.0.1", "wrap-ansi": "^7.0.0" } }, "color-convert": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", "requires": { "color-name": "~1.1.4" } }, "color-name": { "version": "1.1.4", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" }, "dependency-graph": { "version": "0.11.0", "resolved": "https://registry.npmjs.org/dependency-graph/-/dependency-graph-0.11.0.tgz", "integrity": "sha512-JeMq7fEshyepOWDfcfHK06N3MhyPhz++vtqWhMT5O9A3K42rdsEDpfdVqjaqaAhsw6a+ZqeDvQVtD0hFHQWrzg==" }, "dir-glob": { "version": "3.0.1", "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", "requires": { "path-type": "^4.0.0" } }, "electron-to-chromium": { "version": "1.4.284", "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.284.tgz", "integrity": "sha512-M8WEXFuKXMYMVr45fo8mq0wUrrJHheiKZf6BArTKk9ZBYCKJEOU5H8cdWgDT+qCVZf7Na4lVUaZsA+h6uA9+PA==" }, "emoji-regex": { "version": "8.0.0", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==" }, "escalade": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==" }, "fast-glob": { "version": "3.2.12", "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.12.tgz", "integrity": "sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w==", "requires": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", "glob-parent": "^5.1.2", "merge2": "^1.3.0", "micromatch": "^4.0.4" } }, "fastq": { "version": "1.15.0", "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz", "integrity": "sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==", "requires": { "reusify": "^1.0.4" } }, "fill-range": { "version": "7.0.1", "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", "requires": { "to-regex-range": "^5.0.1" } }, "fraction.js": { "version": "4.2.0", "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.2.0.tgz", "integrity": "sha512-MhLuK+2gUcnZe8ZHlaaINnQLl0xRIGRfcGk2yl8xoQAfHrSsL3rYu6FCmBdkdbhc9EPlwyGHewaRsvwRMJtAlA==" }, "fs-extra": { "version": "11.1.0", "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.0.tgz", "integrity": "sha512-0rcTq621PD5jM/e0a3EJoGC/1TC5ZBCERW82LQuwfGnCa1V8w7dpYH1yNu+SLb6E5dkeCBzKEyLGlFrnr+dUyw==", "requires": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "fsevents": { "version": "2.3.2", "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", "optional": true }, "get-caller-file": { "version": "2.0.5", "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==" }, "get-stdin": { "version": "9.0.0", "resolved": "https://registry.npmjs.org/get-stdin/-/get-stdin-9.0.0.tgz", "integrity": "sha512-dVKBjfWisLAicarI2Sf+JuBE/DghV4UzNAVe9yhEJuzeREd3JhOTE9cUaJTeSa77fsbQUK3pcOpJfM59+VKZaA==" }, "glob-parent": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", "requires": { "is-glob": "^4.0.1" } }, "globby": { "version": "13.1.3", "resolved": "https://registry.npmjs.org/globby/-/globby-13.1.3.tgz", "integrity": "sha512-8krCNHXvlCgHDpegPzleMq07yMYTO2sXKASmZmquEYWEmCx6J5UTRbp5RwMJkTJGtcQ44YpiUYUiN0b9mzy8Bw==", "requires": { "dir-glob": "^3.0.1", "fast-glob": "^3.2.11", "ignore": "^5.2.0", "merge2": "^1.4.1", "slash": "^4.0.0" }, "dependencies": { "slash": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/slash/-/slash-4.0.0.tgz", "integrity": "sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew==" } } }, "graceful-fs": { "version": "4.2.10", "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz", "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==" }, "ignore": { "version": "5.2.4", "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz", "integrity": "sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==" }, "is-binary-path": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", "requires": { "binary-extensions": "^2.0.0" } }, "is-extglob": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==" }, "is-fullwidth-code-point": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==" }, "is-glob": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", "requires": { "is-extglob": "^2.1.1" } }, "is-number": { "version": "7.0.0", "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==" }, "jsonfile": { "version": "6.1.0", "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz", "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==", "requires": { "graceful-fs": "^4.1.6", "universalify": "^2.0.0" } }, "lilconfig": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.0.6.tgz", "integrity": "sha512-9JROoBW7pobfsx+Sq2JsASvCo6Pfo6WWoUW79HuB1BCoBXD4PLWJPqDF6fNj67pqBYTbAHkE57M1kS/+L1neOg==" }, "merge2": { "version": "1.4.1", "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==" }, "micromatch": { "version": "4.0.5", "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", "requires": { "braces": "^3.0.2", "picomatch": "^2.3.1" } }, "nanoid": { "version": "3.3.6", "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.6.tgz", "integrity": "sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==" }, "node-releases": { "version": "2.0.9", "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.9.tgz", "integrity": "sha512-2xfmOrRkGogbTK9R6Leda0DGiXeY3p2NJpy4+gNCffdUvV6mdEJnaDEic1i3Ec2djAo8jWYoJMR5PB0MSMpxUA==" }, "normalize-path": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==" }, "normalize-range": { "version": "0.1.2", "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz", "integrity": "sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==" }, "path-type": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==" }, "picocolors": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz", "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==" }, "picomatch": { "version": "2.3.1", "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==" }, "pify": { "version": "2.3.0", "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==" }, "postcss": { "version": "8.4.31", "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.31.tgz", "integrity": "sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==", "requires": { "nanoid": "^3.3.6", "picocolors": "^1.0.0", "source-map-js": "^1.0.2" } }, "postcss-cli": { "version": "10.1.0", "resolved": "https://registry.npmjs.org/postcss-cli/-/postcss-cli-10.1.0.tgz", "integrity": "sha512-Zu7PLORkE9YwNdvOeOVKPmWghprOtjFQU3srMUGbdz3pHJiFh7yZ4geiZFMkjMfB0mtTFR3h8RemR62rPkbOPA==", "requires": { "chokidar": "^3.3.0", "dependency-graph": "^0.11.0", "fs-extra": "^11.0.0", "get-stdin": "^9.0.0", "globby": "^13.0.0", "picocolors": "^1.0.0", "postcss-load-config": "^4.0.0", "postcss-reporter": "^7.0.0", "pretty-hrtime": "^1.0.3", "read-cache": "^1.0.0", "slash": "^5.0.0", "yargs": "^17.0.0" } }, "postcss-load-config": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-4.0.1.tgz", "integrity": "sha512-vEJIc8RdiBRu3oRAI0ymerOn+7rPuMvRXslTvZUKZonDHFIczxztIyJ1urxM1x9JXEikvpWWTUUqal5j/8QgvA==", "requires": { "lilconfig": "^2.0.5", "yaml": "^2.1.1" } }, "postcss-reporter": { "version": "7.0.5", "resolved": "https://registry.npmjs.org/postcss-reporter/-/postcss-reporter-7.0.5.tgz", "integrity": "sha512-glWg7VZBilooZGOFPhN9msJ3FQs19Hie7l5a/eE6WglzYqVeH3ong3ShFcp9kDWJT1g2Y/wd59cocf9XxBtkWA==", "requires": { "picocolors": "^1.0.0", "thenby": "^1.3.4" } }, "postcss-value-parser": { "version": "4.2.0", "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz", "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==" }, "pretty-hrtime": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz", "integrity": "sha512-66hKPCr+72mlfiSjlEB1+45IjXSqvVAIy6mocupoww4tBFE9R9IhwwUGoI4G++Tc9Aq+2rxOt0RFU6gPcrte0A==" }, "queue-microtask": { "version": "1.2.3", "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==" }, "read-cache": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz", "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==", "requires": { "pify": "^2.3.0" } }, "readdirp": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", "requires": { "picomatch": "^2.2.1" } }, "require-directory": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==" }, "reusify": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==" }, "run-parallel": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", "requires": { "queue-microtask": "^1.2.2" } }, "slash": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/slash/-/slash-5.0.0.tgz", "integrity": "sha512-n6KkmvKS0623igEVj3FF0OZs1gYYJ0o0Hj939yc1fyxl2xt+xYpLnzJB6xBSqOfV9ZFLEWodBBN/heZJahuIJQ==" }, "source-map-js": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.0.2.tgz", "integrity": "sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==" }, "string-width": { "version": "4.2.3", "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", "requires": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "strip-ansi": { "version": "6.0.1", "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", "requires": { "ansi-regex": "^5.0.1" } }, "thenby": { "version": "1.3.4", "resolved": "https://registry.npmjs.org/thenby/-/thenby-1.3.4.tgz", "integrity": "sha512-89Gi5raiWA3QZ4b2ePcEwswC3me9JIg+ToSgtE0JWeCynLnLxNr/f9G+xfo9K+Oj4AFdom8YNJjibIARTJmapQ==" }, "to-regex-range": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", "requires": { "is-number": "^7.0.0" } }, "universalify": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz", "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==" }, "update-browserslist-db": { "version": "1.0.10", "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.10.tgz", "integrity": "sha512-OztqDenkfFkbSG+tRxBeAnCVPckDBcvibKd35yDONx6OU8N7sqgwc7rCbkJ/WcYtVRZ4ba68d6byhC21GFh7sQ==", "requires": { "escalade": "^3.1.1", "picocolors": "^1.0.0" } }, "wrap-ansi": { "version": "7.0.0", "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", "requires": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "y18n": { "version": "5.0.8", "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==" }, "yaml": { "version": "2.3.4", "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.3.4.tgz", "integrity": "sha512-8aAvwVUSHpfEqTQ4w/KMlf3HcRdt50E5ODIQJBw1fQ5RL34xabzxtUlzTXVqc4rkZsPbvrXKWnABCD7kWSmocA==" }, "yargs": { "version": "17.6.2", "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.6.2.tgz", "integrity": "sha512-1/9UrdHjDZc0eOU0HxOHoS78C69UD3JRMvzlJ7S79S2nTaWRA/whGCTV8o9e/N/1Va9YIV7Q4sOxD8VV4pCWOw==", "requires": { "cliui": "^8.0.1", "escalade": "^3.1.1", "get-caller-file": "^2.0.5", "require-directory": "^2.1.1", "string-width": "^4.2.3", "y18n": "^5.0.5", "yargs-parser": "^21.1.1" } }, "yargs-parser": { "version": "21.1.1", "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==" } } } golang-honnef-go-tools-2024.1/website/package.json000066400000000000000000000001631465704072200220240ustar00rootroot00000000000000{ "dependencies": { "autoprefixer": "^10.4.13", "postcss": "^8.4.31", "postcss-cli": "^10.1.0" } } golang-honnef-go-tools-2024.1/website/shell.nix000066400000000000000000000002621465704072200213650ustar00rootroot00000000000000{ pkgs ? import {} }: pkgs.mkShell { # nativeBuildInputs is usually what you want -- tools you need to run nativeBuildInputs = with pkgs; [ postcss-cli nodejs ]; } golang-honnef-go-tools-2024.1/website/static/000077500000000000000000000000001465704072200210255ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/static/_headers000066400000000000000000000005671465704072200225320ustar00rootroot00000000000000/img/* cache-control: public cache-control: max-age=604800 cache-control: immutable /webfonts/* cache-control: public cache-control: max-age=604800 cache-control: immutable /scss/*.css cache-control: public cache-control: max-age=604800 cache-control: immutable /js/*.js cache-control: public cache-control: max-age=604800 cache-control: immutable golang-honnef-go-tools-2024.1/website/static/img/000077500000000000000000000000001465704072200216015ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/static/img/logo.svg000066400000000000000000001762221465704072200232740ustar00rootroot00000000000000golang-honnef-go-tools-2024.1/website/static/img/logo.webp000066400000000000000000003160201465704072200234220ustar00rootroot00000000000000RIFFWEBPVP8L/U#Ir ŦpG:(ekdMA-߁IxٰYӊGs5e?dUMHAxFsJ#t OVxVaGֶU͈[-@6?u;;K@-򇧶 lUDgixLaSD :f_-v;^+܁3JqF`pdfcX+`i)2zRl1C`)ƒU´'<0%3c|0be,4\,`6 ْ m0.mۦ2mS,$0!r$1HRr|C,yBw}}H0V,D2$,!103H@JF_sLƿݵm m۔}m$EY= 7咸X}7;&4Q/Ҩ$Une2e[,Z ||ϯ+e' Y ),Y"b髷,! &$ҫ\R˥3oMRYCj"իwz 0fڴ\RB,=\DY"){lxg;EN[}q5*2E ,AHՀv"BoKI)8,9aBeJ#zK}$Lu:8L'HoAL,zs@.bB9k@ RA _W)Y[Y.,ZjLUwVB4\/Cf](3XTruS26em:ːl*WKo,ESnKe!ٛ2..xru)4Ŭ3a2 e()܎ ZSY;SѤ^Sr,3'eM&[YU`/؋eEO7 PډRK[۔ity+ֶ\_RՔǬ3E`6ed9)]$m1<B=@dm[$֐D@uu \$g^Hgzz2lc0e[=iFضWZkNƶqkm0w> m<2Olv2+v9sjm۶Q6^x4msFlglƶ3Qlضm۶m3Gu4:ٶm6r$_Ǜ m$Gr3mݿ00ɶm۶m۶m۶m۶z5$Y$IJómӏl@ݕO<񼿄f*Tw_`""Dy' 2P`'pc:0~+`ːlͮ[e?l=H @f#8$)3=A\0bi30'erZkۛM9rI ;4ՙsu.H۶)*=m;c։N*n{͵\sm۶mkm^sss1~1ʶm{eʜ m:eҎضm;e۶m;m[/ZmTLvĶmNҶmUOz۶mNZnض<YMm[}mnM슈!lVӊ0DJ /XIRDp.D3m#5>$m$I}F*kv/aŎ]h,)B%!0 hp]N>]8[:;8e($9DRhL {тbWQ WH.? S*B|o %#NGG a6!tz󖾜I4;5u0:_F@ c5v`/auR1a'Wv@stE@3 M:GYa߅Gp`[B98l?Xqw>nNG!OS sBK 1¼ ktI 0>pt\8+jDGa9^8>*! r0vZПL+>!sp,5p:Z[uAٻ>BGv>w07'/"OmqcOGƈ+ǘBCv sEx =EiUxX@@$0˿4N@)~ 9GE 1▜}]xЇ{\* ʟ˟= ƓMEwht{+|ѩaf# tkaА pf\(]}LAJ%}p$;GA趉l9Nݾ>9; Emx-+<8špŋ.`>%qIw7jNI#oFmbEKNGp^]uC>0|T?D'(a5#0k)F׎ÿMe)j%NCƤި`>"}Uz_-&~*m>e9m&#v^5îq3jR7c|DT{?ؗ$$5o7ZL:i5æޚYTx.U "NIk:/ [PQ5zp= ]iLmBTOμ9’[MAD淚֢([HG|H+w?lx67OF({(-/T6HoBE9Ԧ|^͢%EƷj]qIqNQ-Ko]]¾'s:t\^ CP{0l:Ιe QkP5 O6r!ɥ4RÏ5KLOw-{ y:?R9SE-&$j o#MX!&{Rot]:Px|&1b79xz}Dsjsv!OҜuwƦdQ 42Ӣb}ꩺQyyX'3n$:Ṗv˧' x=0-A5YeIe6(y{΃p@)̕GBc;V细Gdk1ciZ"¢ Vz@'%@w6Wt^iQ>))XV.v'@h.lr_=5dMNXt ;( VlC a!qTQtQ%"eik^/]'"n%U%($N NnGx38!cF$}?8esTɫ*(bco ~NG0Jq1,ũ]WuiQjDͦ%zM#.^ϊk$"h$> -T¦xYx.(aYA \fU36ǡ}/迃.b2*ӆ:io_jj@FKUyE*ڞޣA /F5js^ɫzhXbdQ.Ri,LTUXvHS!R=-(VDU Z%B m=52DO zq0ݬݼւ2S6[ j10:[!k ڣ:P[a!6 *0xlE\4:)(JtzEkH7*qzE(YSfQh$^S5Tha۷UmEH-Vn@# ޳74h<O4;lu]@o=aD+BXS롭6#JVAU:a>B\OoMQ8s'Gl^VM&S3WyOG 배63J?:yqqjopex p$t*7(difB/ޓ)jP7謏gp06=O6ΒFRf1'hcڳ_ޫ~~GMֳA9lQ~պ2U vm6KdcF!o.G&k8x"E*ؐ؞|Ȋqoԕmfjy@]ȒCx\[0VOv]rvOQ :_Ҩ'4ӦXRT̩t;ݘ )8lZN oX*@叢tӟ. H6cJYMQ /^% VR(T /!Ӭ@xF~J756gJf1~5r$j[kDFJ,.Ͷ:)^su)!4 4XiSh7mlV+~|I>qZ7Knq0)ee4JO=Uu/md.WXZoz`VavC.\^ͦ>=}3a7iůGsI^{V"'5$؜7'EN` @CN!٦z22j]}i:dwtl?$Jrל)h1{I ?CU& ulr.'@WC;̞d~>(T Nf>y|R]eMo* (~[T_o Ke4 %Qٝ3ƜhlAs Vn*N5Lji.c80^aȬlC_'E'Pփ?6J~%L+ʍ=ή Wyв:x0S 6U}/9`/`qqq?WP_+JwITlA5e->*[RL:zmQ~ӈliӄbg_OOIfYgl萾wSHŸBۊ6!n~&(B- \IPb!DQ%w pLh6Zlp3Yp.bk0A_6+B=@Aq0Nؼ!еYt'۔*p~饵`Tj dCIIu˔,TV{[x #V}]6љyaUU1ajeZ([t~B:F\ Wmޯ.lpn45gMRUc}Sޣ eB0 xk\qR~xxl,\`4_H)lӫ¢ M#ٰy@03|:] ^i Ld$¢T<KPAOn6ӺF H"/8,Aմ e ~C\]T Z+6T..mKh]xKp&,OkyBD:֤/:N]=T;{Olsng꠻]f366Neus$ǵM~괦U0v{c3x)@eFm.$iH' װ5*enmajA5ܲ5S8B# N| ZL9,b8٪wl@#ȗҳm)D"B(=Wuh#vtLAq ѝw!4'XF{#rf;p[jhW*Ntz $ UҺġ/PIѰѼ΀j͹RVd!hW|8\ǒ!yjo,`hK5M+vRV*ǯ@j #uQМ/&uׅPY pMN)3l6fl93 "72lUpj\۵Np/g#*ެ>Z;c2:>-ZCLREw6zL8#=m 3`LVq@_])^ DoW~iTf^#vLF;(i@={~3(8Ц5zIBwr1yVlnLg^_up<+l҃~E|J7 ؓͦd>W(#6;PYmfS 5 Ѩ >N? ;%oj3,e&4HZNM?v4Ք9@M@ ,냀QfLg+K-QC# Ҽ9m 4m&hځmc N PHw0aPHK&̶:(W1ˢEC5٩lF7AE="\}8epy6DDݿ8_jum 3 :S9-l!ڷURnciUݠ^zl`k i6tm\VS@,x]zKDl,VQHͪgѫJl Y+:4"[8Q E|BwQP[TdP@θYXi$0*"ՊvcM6{ꛦqml!@fSBæ|6\ׂm1a[yPbb`mDqeI~t:g}3ǗZpqnT r*0* #as,A5UoƏ0bO$Whz/|p>m(tj{ZM$\ljI8` R _Q9G3# Jn;P} Un{sCwJq:l[mڸ?;мAM"E7:֑R %&砎)htH H2"i$ eS|)s~Dn ϥF#tUDb|~yuEd]Mko tA㺨[kxF mCv߈LG2,aZ\ah?C)2M  (X3vD(z!uTpaH/JG$E%NAQt:j:iR(/# w-)AL|~cq!KV7f[I9'L>/7JaRPAt]dxpq9h8 2.e*N\b#МYZM~qj5A >VE@Vƥ3(W&pBm؃Ph,(ӝH6` tC! s./ L|+Rc8UztGތ[BuHFx+EE0^yXV\=KD9 ([n`Yq 1**s(V.NK`N@tͪ:H2/_VA`VN^+bi.dG9whNGcbî2r4(UuIY F<|;jR-^-6L*<0Y0T'ҭ-mKU"V R``҅g!V. +J " aügڀ`>*ݬIn] Zʔ9D"? ]= fӋbeݱB͊7%5&p$#uF5nfݖba|`a¯\",{+: ?$!2}v'ķRX?ڭp> &` ֵ"ԢGnaB2*!w F3 \xG;BC&k+*pe }`aͦ>&xXc:uȝTS̔TCX<@mK⹤'^Yin }o09h'-K堦KO ހ`^NTzz% nw> 0eh f8ހ,Ƨ)A?nLAn0֩>,d$i~0 >J.%yqm,&"f*VVR55 8EX,6|XiE V]$(v cQ'yD`2aM+j2Y?"ӌ hHzn. v :qՖH"JQC.z&B˝LMq !44 ? 8`*Y rUd WAZ`A (p\yQȺ6 o%6z1C \ހ˧nY)!q}0ٕX2 :TPm(ހk Cg}ͭP wPE։Q|^AXu tXgZLւEOsFv̅]*` &$2_Ѐji<{Qj[p:i].:nfEI6)LTQV% 4KQ?4~"8 jY2(+qa$<Ս$-K_ZKbѲ?A3 Y L}ZBh.Jl@pme`fPyVp kE[Rⶵ߬Ն٨#p<O0VFBv#X^<EEr`a GI'-YF#_ݗP4Rb'RRAe4$ P{GP ydꮺA3̢%j(,"e^B Df8t5XĒ+ } XͭpaDz%u%xS2-K*$ԶnUBa6ƏBOfB׵n"x,\hO? GJ.նrT5`qEs*ScR/a:V>udɠ6Զt)Lh k͉cQr. =R#KrWEp]GC/mU|(ib Y | K :>n(l$U/{-!GKQe ր\ |:Н],n)q=a[$tzz؋TƶMћ,p5̶Ve ?&y)j[TRYڠ[(*4x0<e`"8dm9,c0/0@ApeL  $rHl{ITBX@ e&BpEwyտ2#H@e_| E@Ǚoo%"%BUPkb%Sn\T^ih>XFK!``3\: NH4 jU#re$ϟd٠,>)ZVހm1SaV4mTOK'y)7V3>>Ť b ҆;6l5sTwꡢD ;r(8RAG_Dm9 RYim@g8V*i׶ fV4ޝzp QZlf>rvԿMR k"} ]@ri+dU!8-P_ ۊ& |C~BAi ZБ/ڒ&LxlRI\EA.XqAX`\L=w=q"KG]qHyT Y Ap)P19P w[4ǂDzI!oOևqv$޶)7 /+y0u.Rj38|G} 뚖1D|ȺYyf=GtКZm?q!>k&3Xηu8Lj]W m:: 1qJ~=hi~sLWRP{ViDũD愸C ) ޓaRՠӬ̙˫ 36KrP(xhGiTe#+/WYT(lNhӆ0(;7-Pn{b/ rYeMdjx[XHs~^ߎ/W?zM X&;]QNk%n J$\b^:S9-$W3 bsiiW1FN1hq jA+p(=3yUjd1z(NTR NW JC4.+r'5']GQs$j> ѥ.ĽbvaNcFQڃh^`wf|~Zsi4eTRŔ#f)`ܼ_~gl d={@;4 sPWן"x*3)4)^VS}G"Wц=!=y&3ig }Eg4_#}V|"C["uΑcOwwsr9[2EOgK4Y:̅u[;l6dy>Em΢6҉#.8{5^7Ԯև1-E.-.:Io3'YI zV~H>8f/YSY t52DD'fZTiÌD-W[ țKq!̝ymxХq Ct\b??Ųբuoe?kˮ{OW",j gV=].%dQdRp!Iֳڈ@o9.<ـg6jbλ4Qƒ?7ĽHv\AQvkI Q V@PJY.5cxV0j-My̤cY@}@vLiC|}Qܦ$9TХ: }P&O-L,cw;8?yL,mJc :Yjוm9^~եV*K$!d?tO-l5 LGJ,`m;A[+.hYh~cπ5ŲI}n @^oyzʜ>fN:,RXuwo&8. hCL<8V~OZya1w9b4Z.*Њs :|t"z\t5zW%Gԫ䗄w| As]m CVp(r7vˈ/*p=zPΰ?yY}{̲g LԤQ> `a4p¹̱J|qgˌ*LGUD6~Yho'˄7D4aȀ q`]ptQdː8S򏑏Rw˥];,=CV<%!s~wDZi&uRiwΑQg]qS4Y_ypC_O!f#:qeLnrj^KNM=!TWql(# _dX.oӠP2yQs*}]Le86';Qz>#59K C}Z)j[/;ԀL7M}dVwmTG4Qжkr".zGw8J4+QRf6\zas@`egmnDGoq.,9h ޴Y`C7kva\QGU&Ve(qхo(T:Sx,L=uљI>z­(" v XpcΊG#+7dkۜ-|ÝRNc4U* o']d%{&A@#$$fC&q \,h8&jǎ13S;jf!C ltu)nbF%kl8 &Q P}X@DUgԣf<}DCgE8 N ݏujx`/8 ѭ.ɬPdJ@λ4- uQNԨX,)j\nt"mYcƦے,{, 0Й,$]ĞPF3Rr>#{r?}$*ux@JD阀wlM*uer+ ,hx e۴CqPE"9oo؜.tqax'G:p7؀d~%h"i+2]UbxyI58y\9%.Ìt$DCu]+WU=&t)[~ׄdv oR!wxUU^i[~FoR{Pd0zȥr,.w! 25 EIye3@P%+8J +ncG/MmB7ѻ|:9WH* oDp 2ÚNɯ+gʑ,joQ&IS؄]3z_1| tP`l͛q"W^l=mOĈȖad`t2Lo=RHWX jH [ȇ% 4耝VYyi{8"*5n( vn+j3D.dSeg*C!aХx B"GQR/%P1ߙ80 J; DqPɦS 4=U>3&Ù1Q13Sӳ*/#8:Tʣ˗,"jӓqcPn/OC g(_u<$+hPLTXLlH*>5x-BBAr84 TlˋzM G wQ-٨DOSٓ uzLNW,};r⫖;s/;i@_su^>'% (7ƣW'֕L+|+u-pyohHdˏ֙)p-p<qԁgtQ*]T h8ui027\Fe٠cJ?=1y>]E#l-ɚ)魔&\򸲡=7q ] 5̐Te#X}? gEeuT)X(/Z[}8]\0H=P9~ʡޑ- _7bGeRWJ9s]y/COŢt˅ڮH ꆄm,kr)s$0 =/;`1:4M1%YWaUQYpr(:_@q@ː>i\&tYK =YC6Г)-zƣ KG]yQ󔭅98&h!VPieGC. T+>3l:eD27'>|$tC yIl=+ЕYU(vO&20'˱i ^na $?AXqxi]Uki. = b@5,,> Q?q{EWL컮*-Ԙd~r}EG8,=%;ʙ 5ku^4Ldt9K$(H_J\CH3[50C1C BiZb5l[!7ZM>[fZ72P?ϩJ7\ ^^!@1`Ά"Qԕ^u'md(;˽j`G2(ỳqpeTQW~ KORfA~.wJF@q~ؼVb8Qu;Йyf-] 2][=3Lr6τ|6OMBrBW:Wd-Q|ȕ^W:f)m$'- JD4D(U>iKcf,$8dte8XΔط.l!槟ỏ /vuvD{\G>fN! V/`v-Z oq8]-`"ܱ4F~ E]96MHls8# / wR-t@X"ެO9x-/ltEQ ̔gB:baV7f0ЊG\A!̈́J=S4'Ф$^lteQ͌E~~b.lIInd `rjZH@"tQJAJʹ1㤮3 g/9.MU\ $dFixhy%F눀{z\kCF@r#i z8YEDžԊwu!O[I"l Jn314H%7Gș1]ԠcJDBxM Eִ:WDkdJU,'ۜҪ.hP>T~ 4-2p֊f r Rr4b([ǢMY5D ' C һ18it^mێ@nwsrc2b5VmFPc냣 2"E uBWDUdՒ\+*;.^CrCะBH/zh!K%t"[muq eoU:NjL2P-3@Ɂ YRj7qiTgB.\4(z*܏$ rs Q؜VuU."ϖHW>UӜn <; ނ8V^SVI'UPӼ(?9P6nPUE\CMhN'4q-=B&+!(tOr*(Xο̫ {qP#u`E"]J4Ȥ{O1ljTb u *'ZMK[Y]`iefYJWHUeӅP+@X64TfufV˒"zSL[їr%)pe'TfA ̥A_Cw!JepI_|g6 xKMª&J|`Z↸t뫆{QxaFHz }V8OAK,](fё1:m )E'|R'&c'YULaM܄AT !%ȉgL8H}Ӝl\azV|w} 9p .*PV roֲtb?NeeyUx[-J Nvf!hxHB,T+CD2"V9UOx`e{ D+!J͠bN9av,XQZld|ҔE <[Z#iVfᔡ*p"eSTQ @U8hI L HW5 FeIR^]U͏GS럂jb}kkݐ1PC_ZTr(PMG%i&{P3砺< teZ0 dfA*Tpӄ$t`u .x+ٯDfF<xP0C몇ȁs|@Qd:#Wt 2 IZ3IɐCD1X*Q7s0ZNE@QlaҴu9R#l5CL4c| GRT EF<[ 2G IDOr*WTxL3!f.p(ҸTzCFb{\נDŽo㙧4oS-_xnh ż*=tD^<e75äD\\rCr\jFة!Qh"zS08Τyj,O Cf`↌!lxNv,oyx|+ `DV<:,!B5C(gHszay I}$Rr0 d5#B#BE yxm5=ISy VXĖ0LrPƂM2:m=K Nf:):0̢>thFl:¿fC$#Xb*TF##v>Pj޵6dd4J٘|V$9T`ip(0L$CE"N* {c3i}%'3ŏLh@84-I@8ȵp. BfcUcr@4?; Э*p.rGo h=Z"fl8IeV+4P]Sy?*W9{6LYiFWM8U4/bda9,W4R(t]hPkH]bL5b} P(usCF7=C?!DDc-P􃳘H71 ?4 BT[OaL3jsWcEKӌCy`/&%4o38D/`>NķQO5Y 'N[]=ޘUGxL7M5|w/;' aUԁ} b9dX Zh@4B&upa\$  ud'FƄu(\Rcwd#=Zޥh.-xwTؙW L]E`<!y&YP}hܕ"s ]s!A}.t1UΆa흽BpxRg*| {FB Zv* {6rxK&l<=BtSvӠ;Z bX㨫)9"H=a//U(&`+ qNвUʃ`B]b.@#V&yD\ Hd]qհk%: ` `jV#Sp)`\1gTT,c`{ 8$aZ@?tIU@U*Ed6FMP JDDaI!}áAn  'crL 8KWm&v\|F p*nWAIPJua!- .?p[$G"GXhxK MeŸ,`ب*IxbIzY*zd« ,√h ¡k6Ph ;%fiDxKTI~M'"+iȔEK,B**H);8 j1G ,8ԢDYԙa]w$Yr=Ts"J! _7D٪IHH`, z DGO$RH0Ɇ{|nb*--E`F[@ŏJZCфQfTaUD%* A"ctĂ ͫA Uv \JFx9%6ax F-&8Hj2b ߐ{@~,A]EbĔC V "dˈ.d=ɩ@`Îᡯ,N]Y4xt P{$5X;6`Ԃ!.1j3m-;\;Or8"p@9 SCҸC΅ׁáXZ#&dhYTa=q9Ԅhc#D{}PoLc6@J.E"(au)hu ȝjzUdV D* ;eqxLZt[/I |EuGteNBc?طzpA0m`ם=n[e ŭ^kă6JH99@I @ԭSC*@xb빟G%F^%! 7VJ8Lu`D axFrƾ{b :u8:O Q"$'pL]BbN=H}`67(*8| mnMoyǓE'%G;r$@=$$@PЉ( _v7pW2}C7Åإ!~뒚7wʽHxÞFW H:nDd4FH )G kRmC Ipq9N<0YeO#a-&Rz2DX3OS셦$߮C~p`83qQ$57Z&HD6@ ɪpKq5!:7x{9-ɯGhZ\M`Jn%t` 7rv!rg(x Ҟq13h8cn5VXJQka:SAf 43t AF<=tҊT@=KIB=%{T2#фǍ-;|餃ZC*5 7Dc/K[4ǩW R8Lk!gc[p+f souL+JVo4Ά0ArDDƄ=\[ģ#d-n&:9[ t>D> 0֮o2b& >e|L}59VaFHǒ3"s*ZO3%k;v? %M"(naP\]ˌ l <9ӷ%Gk1>tu`-$O/sfA5:j\2A>Hx:o.~?I=zr%Ͱ< k UdTVҞ%~@]:R]aQùg6rpm*SݤhګƐ;CPSĬirt\<u`.8Uɝ!O{*KM2gg OrR^Τ+Z\agS M 4 @qvU5'Q $Pȍ-S/N.yV9_nW6 rE˲/ ?\פhv[J#wjVm9{V۱tږ0Qt9DHR9\'@$y@2KnbGr`ZR1ZIa=2>VE$5%T 𒸍@>KMu4ju'0EpCvsR"'RtŒiqE9B+g"GddCejìG ^ gOEd"}7.A?.d0D]x@ 9ŕ kucҜrIS ԱrCCnVъaW>s$k\>ܝ@k۽Oц8W)8Yp`\0Cg+,vN=H?9&K#  MH| at@ԡR O %I2w?BMl tmk:C9 ]R)i<:I b%a]?k\B:`rmq5,VҸ^&PՄY{yQԠСM@ѪBQ4`%Q6 gjWpB8J8-&^0~kuLwȂH?>Z8<œY`ӣӔ H7X4)ӴBɰn C~[㔦a59h?*~KS^;gg:.4҃2(67O=c%j7> ([Y5 ƂIdHVi a编M(Q  LP5@p5 LK7]LA(nOCt\ioC7$89 q!,F`N|Z#9Xڐxr6tN<2;`7bH>Y涑LKAE4-|QE iXZ3tOf\U#*C*Q&nl"h G-Ku St*La 0Nwv\ReTx;iP}@ZI%b5Q'b]=#r/Ի ~J |gWUsْ˥rCgu{̒3/ܼV F-bhB;%<̈́.oônJ%ĤsG,Q[P{M];dL0G A5Y'!}\r%Iz%8b(GсQ)y2;So`Λ5;!.քUOoCJM|B?e2'tJ8 Ge}-y2'Gޣ2"#%JEscn=ULqZg qW15λ'HbC(K(|ScU[Ӻ0$I@XSa#I@ôvb0uoEPн_inX9Qwӯc~=!x>Iߘ1Қfxtx%tq(´&&:q}sJ6)fh-R&|PR?J{:d)uNwHm0lG:UClarl&YGZrj׎1WC0h\w@#gggi:t{̳A-b fPَeT9`JQ]2 –#c!Y7c7[!$ՐL߅rf8OѩѴ0K;"?b ~g*_Irg.=;nwB `\[`nsV#+4!ٺg_ 9B Q_rsä@4Wh]A!Nh }!N]aFq0! xAi$ B7X>e Cn#ڽ?__m&ݾ$r\IG11dGRoKҞmz00U?WNL>h6.8BgC@v]?F%=@.LeY:m8jHEā6QvR5%W3!u|Tuybbrؔ&5O^c]rΗ*6%*A>OX%ch.aa9K:ƴ%!] ]~?uarlC zxȔyx# 퇷9hY! !M'ïg0-%KBCD=d~sPD_R&YgD|slR~[U1a.XAX{Q6SpRDm7d<_Ijp1욅dؤƔ<-,9< ebűl#X |@ xy90'Laqq dA1'%sJ;iW={_A\9X25|1T0Q_B(N( ]{i6*{}C\d%QĈM7 $<6@ȃ͹< o(.3ߗFV#/ {TBEK/lI-]oƼ8BxcE^I#Yπ91rU4r0!b5tq_Gȵ'Tmlw.ɡu6q1*ɇeKt%'{)yZG'Sag6}PZd7FOD1@:* zQpq6a1&OU Y kv2vH| i4vc,s kO1|"6o0ރv'iBGT85B3]ڷ GiGFjbjntXՠ?{"UjoT b$K]3C)b{VQhSǐO};gK;pq.bv i'+4gyO\^) ;$䪍bxl:3э;d R,A`{=0h ]z[|]Qp{I WoRf9Z{FV:M5!@znj׎& m.τr^bdM r ]7LIyAh3Fo ^<~2 VtlaCW2_\ j^C&%388K~*gس56="I~wz`u(63a\ R@h;{6A`Qqqu)͐V@Σ`:IԻ-:M|:]h95Z<|kB1ǰl}dshH t&GfiO~W᰽KX4B8Hڨ.z6[- nBiZ&ZD 'k0~6 $ PS"$Ёx*ry٦&siJHϠG !T6 >=>A 0V<eHm8hۿǤir64*G1܉­I0ar c:~4IzN$Qa Q}yʂ!}Zm?~_x ԺJ܂fbHD "B?lOt7ӕj%grV85.@ ~K8x)gIBvݿPr'a="ʎ/y FA%,حO~H~5_sPIItq$c˨jnn6*$9 j& aOH&,2_v~^YC*a v,~C^'O k>Wi1l{7ta4HɵŰ7<Fs)sȃk*~\͗x;& F Nж{M6~(">tvE=Wj2Y0ŶjmH\T [MX$FkP CB^GE4qD !;.D<0cHXX}"LOՃԱ2uڣxN͆*thY_dNB=6YoS@v1Lx .I΄} -Xم,fh R Q!;ۋ7$0{VQggůK9u~M Z7~fixp@<͘ vD;d`}bpj*{yPMMN1u'x?pL> 4 Ɔʪ~H)Ըǿݰ)dWk2 E3 vEnht E~-1iBnti /= CjbV[x(-6P1 X+>Nk6)mc% dD QG/4 #FX?Ay;#|h?Pp:Rn. 3,# ͳA\*Q:ͳYCȊHhX /##T՛&-5K&t.Œ_Yb2 [;mr(֣w cx'ImhVcL9 9 ~癈Yx<UWڧDGѤ,* o/ t`} '*{w X+b EVS N;EQc;2u& UoG6:Iz\WUs'`Q19 uG`অ4f$ 6ef+gtBӂH7E,ZǦirb}-u { &qec8ײ=y0႒LȸUiÇ {gDw?̂:`.~zh6c1s/23 *l|U#hjy|Sc#i551/d|Pa! u4bfѓmH <&HH;[q&\fԅJ8\t*fkªe`i_$9\/`[ΡGJ^{8#1Yx;I6~("WͭTBN͔z@DmR#hFh3wf$QD=pHQ cԠ4e*7n_Me :~:"1yk~ȧo!lW4*xrLX% (d$''rR@+xy<Ⱥq; -ˆxKE/-~(Խ󲫬r(]!NP%ÎbwfHz_SI{j?q4t~ًiOS!;0rT;c(0QT`*R@b21n1|C$Ass?=ωP-;ڽLh6^ttȶf7OB.au`3ʶ[0ˢ~!"p\>4 OXBkc(humMf.I/R$Vb+{CPpvsUeϰj wO{rNf zn0CZ[B02<섫g$Q Y6ЏbdMS xuԻiBr܂eQToB uTGBW@֙YP6PݯU伱.H3<6) _R`=G , )kVוw5 ^*ةu5G47GmG@h6k1eMt,kbne:f b&?/Ū{L __Gm8I@ǐGx=Ee "Cik,MCn}A g6YU/04Uo"<H\/[˞y]Yr닂Ƌ 9&qD< tbOcdgO `7pac89:$TVSކ:/7jf exM߅g O7A\)츍Tbƃ 7SP2d7ݢct. ZsĦ&Z56 N5qutrONWHdcxB@1O-; :OK9_Ɵxؘdž鼡B8WPY&*Ѹx0j0 3dP2i=e+sv%,6 V丱i O{Gp&9,zbIǾ6,IU#0QXnvC]c-(QmA%,Pw쳽|}~4J2̔AimSg"7hhHҐbɂ?.8&`!7b/>"b&j}3=U>( /֖5*kĉv, W #5p 2"N 5Jh!X(0ͳ:S$;6n_f:Z2UW%gWcU&歠s./Dj%J(C~Ĭp 1fZ P}wL[&kzT (r_vPEsS.2ޔ%QB2SoD(Ù6 *R5E9Y퓮y g<7i "LEP9sdʿe7vs7v:)`tOQ o{#Az4S!`حK?͎$,ͯe /s2SVİ"؛89]\i+bnĆQ)4 }r( U|Kl+DPO^bop]^,ex&fo8hFք)M~b@x4Qz5hiCs(i&%;;8 bpFjT4x2 t4qXege!2{VozS3 ݎ{Tb'K e:fϸխA% yfkқ̍8GnMl [;RaS`o/tzMV~ ȡFLt4n9 "v64/sCx BXt hO'@.0 9&3襲ab8n%z{\%.Ya^_}hBg1y])&ơ~U݄1y$gU.αL ,g.iH:N"FM5n Ls$9xd7 Jgfqcx/=jn}l{g{y@d<=$V7 Ā7#S^vn'˴p/ %?'\]FBw[}YM`طt2xn N!xcF!L{}Z:ClIZQzfvr;Pkap&V2VT'@֫6f0VCM;lG H:I(U W4Hpr# ;{5*nOQv6d.vKet UׁX_%8]ڻ-X22m">3#^dkz/n͝I7n-g "o@z~8Hw$ O@DCTOX|4#@z6SM{>vaKU9{?Wg ?@?9;EtA#IB):b_UzX߶F'#>*°+aĎnW'h"ׁ`W}:?S@9NRiY&#To,@7I ~7'MJdE&k`l$dZGܾNCe۟'Ȕ-׺~HU-UH䌼!?ߜfw2F瑬7֕ Li0Q9@U a(f,,%w뿼!!% &ߜZ=npEwŰ[ibU ]܈& dT1= W$d ?\~Pӗ"v%}d`.?oSpKt\ 3俙UpW`iNlTTNd MD`#ʬ d-9wtޒ[I~U gVᥧ>B⨪P Ƌ`r$?: -{FH(oL"z /If)k?M>EƗY}BdtӒn$yt!3cѸyРP~ցFmA#H:Vn8ZĘw.F:OںdKcLn1K.y4ZUCC A Zt$hUJ"8o@A+%X L$x.d=_9N4~% ASr˒=h6fG,`N>T$XX#tиlU1V.](u])|*tbO*g3o^@%x`&A]O}m<&˂HyfF*8}ϴ{q»g ,w8݇0U"Yssfb _Mw|C42Ўz-fȥS}ș_x .At"5cWR?_&.#MP^ysv`ٖV%7*`'8 _G >A_O h;CƤv]).{uB¹YJ$X$_yS3\|+UnCYM21}yܪiD՛k :dnb}{#tK2W0UdX=ň1Rʌy[)E',$hBR=@UE$EEc 5m!q8w ߼Cfvיp 1+Gn&c A F-j~H˚\F+aK/ W"b8N/hsGjЬUŤX!Go6c7- r -[!XT -'Ra8zՀ06%_؜R!tŪ :c1)|s pJp`AOC#)=;,bg-_,Bo,Jk x|8jl1=Fmxy`8NphDD:YߞhïСGüUeBUj]T :?#! +zb\s|zg~o6sXoG;ا,C0U[΄Gb f,N0TwKp A/bDLF0z|zğQשWħ# 7hkPuD\,Iz\ShUCpW*"0 v5cڲPNH#RO+jCXIZOɶ[p$H#2Ć 8w2'j8/ҁ[> MJSs(+NrVc{s>x(zPL YlpJp`߁2 ={ q)~?8Ŵ) W&.I?z CTkцEg:^x'{ qؚ{SEMp/mNh>\C(Q)ԩ@J+Q!?t?\%znk"!(DV9lj8F%5铈 ^B:j*3}1tHg>M]Y[Ѷ|WULO0 BB__(E!BES1`|ybV3@c ^=rԭ?R <ö"YȚ;';:Aiw!LNYU*L8&SlSe%Ua()p؉kѬ5mjSs7-8 A;iyTB Y8i`$ v!b\UKGsP]ynjڍ>H;Ha5U´cl ?4VʄgV0bBZuoz>[W؍UeM :HM )t5\adA)Q`?atroCRPbH_ZMŷJPLq%E!pDVc }%lt)}2jٜ}4A'Uծh|C:0Չ0} $)18aV1U`u*9'ltW`I*P+d6^Tp=)9"h!MtDi?ke.4 sUX4H 2$x.qY୧4یJj] +ILʗ)% MrB7ci p9k"F5C5NP%7}U9v&{: CmDf|B,Hc7˓Rx*#eI냔w1Pg5s@' ap %9+" Fqf\[HWE+=fV2HwE܆4T kUU@GR1o?iarADK z; VnV&4uIp/9`r֧M$XD)049:0 |Iq |8AW 2W,K4t6@EN=|F3T6ZpȖkۗ (]\3 ,AY"S8 &xL.y[q9<+b]}|8[bG"rm)ȡC@Lx-=g*&C;!fx=ybd9ֿS1ODVYNݘd"t{zERHFT4j Mx_f rUZ=dn02Φ YuAHtJLIy?!S^[F6cFavj^Ҙ-qO @^܌J`OW+`[ΔVU,mJ̫)z)CdyɗV+{~cy>D/fNCLΔᔦ Qc$>`.đs |i!`?x6=A[c=Z9j­bʍ>\;0ÙVS~&h^ *`Wu2:ڧ0Р5б#}7:m^Y:f=&LeIs,^I z ]f!COvXI嚮A|`&7A8R9mIDIJGiGPY;3@>1&3z"<)@I 0tp`xNRɋ]P\. V~:eB#X5氣7PH㜿T'e%h+i!; TQMm" 8mkiU:@UZ!dks+:x5-qUT4ov(40CWؚA?"X*d|*e3ct:ջG2aCJ0bO0 L땆YS=DFس/d{.!w/ L|V; ZT!8o+[A0fyòާrFfv $!ݜ%,/RWK$/ː_E6{L^pW4Xr աNMuDYr@Я0q>Kʆ=O[ow]P }Hf\ |;jʁ-{MmRt.`K+kGxG$QϦ4g`7`Cՠ< 5uA!Dþ?ZQzwZπv֧4)SKH8pY@Z my0Z|u Pa8i@6S^ ɣ1>auR~ۚ=/ ?. aM-;3<9B>}yƢE` b2/ (5w"]!څxv+KӸ*9| M5g?&эc5Wʦ #}d?V#7},y-ï[quIov(d=B/QS*?F?4T'OIP r9e4*pxH(+ U^taDP`YAq")X<I?b 0o;J^&clR.7ZCƌ"W "gG?s|dU}N։==vIa*}D &2*Z4pWBޗE6~/tN( UKÎikLUSS0t4,[&f,H_ 8>~ZRa:݈IJVHkGӧ0[ ^䅼aY+94?PP3a8"%~nEPr2õqcMQղgϥi{9`c8}򘘉= <5ESt9ߓMURA9J]hSCSP1@j ;[#\r6py $L ͔jg6? .sLzQUބ73Ü"rP:`ѕ!z<ۯt'ѦIWq2 %pnP<ʖN?yҥmc75"tk٣tS^f"z@CwڷTs/jgC pk||p-"ٍcQuSåǝ 15+mB=fÆ hO禎dDjx+Sxǎ ;Ѭ2{ڵeN_8@[ɓ×.7@ۂCzώqlJ(>)HRInn*M!^ֿ=4Jz|Pk  ?Ae!T193~WuҤj{5 A_Q ("X$&nI rA9`P g?0 `l5v5H%*k6d^_A0@套y0y W7?zMj 6_$"<0ͷGx0M}IKkP"YuM~.q>ktMjt D(YQ3CxP`=C7mg.e|Q5hMκghr@ т,J<{ qTiʀ%;,ǰ'[?V_ U*glt{t 90z#Pl ` B]!*Li]ϟRf254AaS@Aסdi7EHLP h+l c2"끮I P.]ZL<-;y$ פ@pɷj߳ˉ y5~$ AT;ŕPЧPTFSvO\)gsz-h)̀Łe>tҡaoo<1,\+ |b۰0yj*}pS吂*YՂVi8?6<$G9J(UK&℡6rk'2<0|IH`O5Yӹ.}Ij,sͻ ά[:HGsSkVCGWk3·Ayޢo($?pΈjT4o0tz8 *v@r[\WCFm=A;\'߽4FbqD+1v1SSvA;5cڎ/I_)`yG pJmߑd - PJ'g=߳nS;pRP9`(25~ҀAe܂6g*ˣJ]#S4F kv {RlÊ`1c] Vk. t>&1!~=u& mr/:g§ao雗2:Tvڤ,q 0xo?PH!U5T)TH0`3bT!toeI&&4f@$n*+X $!dVŒf:lyK|ؔhǸT)T{ T~qFo&"I~sPWAv‡+ %wʿCpU(=@eY4<K4Ç⏩gfZ=P5ĵz>ZRc:&4"Ap%<ryK@MQ \yfo;y~Wkm4;ИWG[t0AFAk M~]߮2҄=Nm | Y7dQt@;к+Ikha*՜)9vhH=~I:PAMÃE1?`;i+ HlW iOQuﳱ.vN☊1W9hJװ~E0` LѭҏV?jT6z}qnTH #=69d/ЦT, 8X@hV7(v>,f< cJ(R[}&@_< )YhW?mˌQ OqP\Kg6BJ4y?R9CAGHMfWZ "@T+`1/I[nvٙw{FBx216LNJWw<1̗g@!.wHR'OTɦ7Fo "q89'm taҼϔFhL04,ͽ @.5$9JhLUURP< ?Wu0;ERC, [PU*Ow~ O$ SN" 0>0gHcd"bć=澾OW_}503GU5ppD7 ?ERe 2rݦ S+J<;rRϋOj3^ٖ0ue* /-%[GD|6K12׷b~}OI>~W>_ 'e=&C+&p#kS5oLXIԈ8"LkgCj9Z$Q ӗ-H$>@L$ (H&.--컔 ICLBoe&ОvtpMEB4#ּpj]۴LHQ39B=? I.,@\ɮ$ x1HZnaZ)ɕTݒ҈ŰBsŔEBL60Ul&"W%ax'`Є3Я)&lx>*Lk0kH2rٌn0,iy|k8 X_ħ"_iֹIKX,=PQBVR\aIa[ "@yiLO `/ Iv%ޖD'YL !OEF:G*{u jTR4m]L A E)N +t=4,[{ʥC'{fumd8``]љΩi1NCJ*(susOA_!A4-P%RɚĂm,8N;"yjnOX Hr ʹ;F_}@eI}=%i/]8148GN a.cxƘ1/}@lB~A Aa.b<ց!vG~[q=>%]|UBD0ɲhϯSj3?3Hɐe*S TP/4y2,UJlYT:r"Ö vx,s,{O| ^5fnLs~PjƨɕTc%s SQ>1x,ožh\1 缥:"ـ#q+3I. CϥEd:]DwxRv;9d#wYbokh1=co7ZJ6mKNddž։,X]qgcr0.`rkjY ,ɦܐ'TDgJytHjusbΤNfRM3x袙L]M]&y<"4CU #*I̮5 |yY$kGfKw٘WAPŞXX3).x ,~8sJjߓ->\[[.wI3?$SzMkXrxZV-ek9cчe<2^Ni/%Ͽ UTvωoצ卧,;fԡ-?L#KvtJ=L639ι7eiґy-&`IÍ$T8&Ĝxza1gzkӞgR͖ 1)f6QlNA.1\ нg 01L7WҨl: @M_+,C9E^VzOSV^{r@@9םRS3ϔߙGzX SmGڋ=_r]i7ܝDD'd𑽜OhRd۝=d$Gc'Nj8bĶB_۠Ƹ$y=L;./I7иIm- I]Y+}ibYüJ+e){7k!Tè >{a/v;|KwYZV9]he0^n-Oj<'c)ԷV$LrzvF!1Aӈq/_z>`L2)1 ČAAaa/BnqS< Owٷ~.1?8noS_; ƖQS+-%ABn>iOg:S3)޷vf(ƆOa}KM¾Ͷ㈼ѕMsYƫKnɓ!>+KJ}+mIِ̙o'?%jHiDE'?560ZbaABByd|շ#y߳,t##rtiOn>r8ļOe`hNԇҵcT20Yα}  97%.\ҵ[! "cKWf9L=Dk1},“Rql6dʃ2GMZSXR&|bYw+NWR[v / v 5)qG_e<ʪߥ$ܕT0 IGJH d[cEf,i8@=pNZJ}Kz3E%zYkl";WRԊUp5~8WHj=07uHc/wk>`2juq~^F="D o>}:wɜiۺۊOi7Q{&rK3ŋϜMWųJM$lcHgg3lM^6%̌̌w*0"%b9,GT<$  L@m6ZAt#߈?ߒ.8]?yȏlג[$Fb>T7B@H' LJ #WK[Z I'}=U|uenO4)e(ǿ-@D?1*vпvsl;}چ5"En\Ӓ˯i\Φ. KDEȋ KԧtK\#\9u( `,<3D @l;@2  FO˧zddUSY='xX9ʋ@j F0c™![y^q _Hh4mx@( $wAH 2: 卒4GϮw2ƭrMe9By|qK$[̾)M)' &ecVիR98\'x Y^Ԯ -g 8щxyti?MqdQ0  -gh8dW{[`WSlDBѭƍ8+9}8Vů@xoK T\[?%n0nNz)f[>֕8BeQc1?8rzLʉ(e'>>)'~zr>rsb+.7ZO03aNtv3'')t` yJm~4_/7{P[b $GU{ 6@ ֝}B8) H8+Nٕ D}hMfJ:5T >8)bdX%҂[(,"hM-Ft*FtjbD]>nGRK1T̿oc?k31oJ8L->~} F A1}2Kyٗa@# |H)#7[*t@Bp3Y`*K" P Oz0{L( rC~sѢ91yAuH/ z)\Svд;BEtmʃvlNc=||,N} oW== 6"mDyKϗۍUCҋLwR@nCSU+/;o+ BGA`lfb_Q(d˄+ͩAgqN #RҦWcfg]Yt^ ؝eˌ܈5O3L *'| ~:yG $C-))%1lƯܽ2X(k9fðAqeGJ@VM 70qB5aק1⃕\q8y]' vɕV?cg7 R{PՁ0݆$e\̴SIv1PAU.4 !*bl6*'g fB(kԥ)NObo-] CJ$I_(iЇ9>%A^.ͥ; tpȘTɕ!]FU~d k"tVBzb>a?ZU8?+n/$W|L8):vB_Cf6%hW[~Ad!v1Qsf#\ cJ/,&30&(!v֪CwO>FH ]_J zRc In7 Io' nVz)^ ۗ12&BuՐb1"ܓԄB!4Lߍ:Gz%4wӘ'L"J Y!o I5[߻18^ʺsQƤ T]0rthmTTsd4y,BUskIsX k鳣512Է8!#3*lXIe(<'u-tTwqD %| "*1aa^B5aA),Kx4kb#б;?ZHܤaC%fPGRjaܸ4&qr΢bv:lʲ4%,G>w ŗмF*XqWlQ!r.BIs1!'8#9Xx}4[ISN!NH혈?{ߨS^w}pIN}R]gڍ7gPr+y3+VdVc;9bn0p IxVxF^֛3u|QRS Sc&KIbNlz%aPί1 mD9XJUŖ+"Fߪ/@?~Z8(2@$g_!ˬ/|d,t̩f{2J}' @y4 ns#G7hgm[PԡdΥm,%7 Op: .EHn5 ܷU-M6cRԽRs CHjeMޒ89&kPSpsarG(Ap^hX㊦X"Vs'B!gɺl."gv\g7=v[K2$SWT}->[~__LɫuZ},(\ !ˎH =a,HjPnU笠b؏e\]AХIV<73zH:1stJsX* BCTgRRG&4d"\05,) ![' f%OR {xE 693M]ub[ؗD<*~F |U W$Q`pc-b߾c6ƿoSV剞:ѽe`VυA(c!r~u:sY@;~+g"ᔑb+},$^#,lf .{w訩d5tf] #+'fV0e fc.L=##Q&.`i߀T@)}5*#t$"U*wL W̯ m@/^B@&ʍ#;:H [r5km$tP%"~R"54hq[&bUb5X)KӇtrKxw-e{P~"|np"nEĞ"2߿4埿J27+?Tf*^D\%4';qM,g;rmz?kJt:g:gVٝ]su;;9Ad%.^#%Ęr.yl/UhCl} i 'tggm8aȭCеc褬7)\BM S둪"b:  (fjWlaSefbṜ:YElKjS͠K"v\X)!~wԆ+}W0Ae"u?ybrZby_3U0Bb?"=uT[c0bգiJEJeYL8SuDkiXLG6cL?%PDO܀,0\Uh j1NAо\n j7'l'.Cۂ/]{+Y-V~i{Mzci!si|? mDif< +i,7H߫;sq9ppLJUފF'WX3j55¸uŰ%1)Ҥ*J5 l#Yjfj Uv+Ny=3) !$9# >/ %; +X+xCikq8Ci8uAIFB j**|XߒS47 ųbARO㘳*n6}MڠK/06 9m*.Ĩ{XM> a=|~;Y-O>7ǹd=aմ`JڃPم"65h6,FQRo's PLjYt-l>5sgJ{P)L9[}/J}˾|sIpr&O|57!tq)BΝ$̌ܨZ2zۏ^1UD ٘|wFh9viSu@6=4p)(z9p5c:VX,J\5OYByhb o:ssʐ]3,.Fǫw:=u,6}eruHg/bNSцBݪMzڹA @a\A~۰Dpv%% TFhЅacC{52 CeM@P{t"Be0H{ {;iF%$[1C6yCkpL/ЂM_"{ B)i?-UJ;g4_vAJ,C" N߄8q,T*WUehKߟ5)*s ЅQUwf Dۀz{9𿪺zEXO7BLIO[wFe>+}w*< 5zg *Fvn+6*.DNYCQF[шK$hcU@jЕqBy#4x JoD!{!ׇ ÷^/B8X*{ԡuBSp[ EhHV=&ẹ&syJ}_!ߑJ2! SRq UQ*ko>=_~/=b$:GhEЏlvk R bT"UQ͈D!U qǘ Q5|xZDP9+59OAP%IhIP_j,09MUG U+NΤbr-8 7NTM@H+@)%@ٔ1ϬRA 4EAyB-z'*Mo{8c*{bү 9*6=k |'xGNXK4e_C[R}4u9e;nkxv@ cV,-ɤe:cFDPi#pF2%D<I!9W ryiK B_))]rAA;c'K؎Rhv (Dqf%HU,.;MsIE׾ЙPt)B|B0FAmC'V[-qboٔt 3ͣe E75ޜYqOS 1ԊnZv\yʐ]OUwl*lBGZoELXZB`r!dd֥dzAEQY\@Z۪2ɿN &vyt>W_ -2KhX/3]}q$Us+bPJ#(z5pn0Pϡ t Bi !j+ـa)5 4$h;ª ҅@[BWPW]".W 2rtJ}4je,5/vHY~ԡ݅:ºO=&@_vb]"D~Xm&/ wyهRXbqVXgNtڑ@]Ve D"?RN9]?ez-=TPyu5 vQU0ߚc~Υ<Ԑ&.c= BhۂZAi @jp/6XSPѝ3BL(5!$B:HB(= C(c,>$SFE$5þ*K"Pr YvtM@ٔUOI{FaZ8c^enӔw;-֚V,kI|+,͝м Ƞˎ,,R˰mɍC$әW+s7]_10C%aXL*kB@6%Bw}??&J QH@% hQغ>vn&iwH#A:RFanKMTqF)*k¹iR*en<6Y*7ZVJc-)\F)7GbS,N~@rM"T}_xN-2H vj?\c n<~Zp#A3Ae,]!SZ@a2:9?dxҀ :y*B}jƜw=cOl. }&(CCy"8vP< '.3ANrڟ{MqDRQ30J>(Ղ~iO0(C$WH-%;2\Gpaj1}B)9&}(u;${fwI<&qBb۹eM<5}v%H>2|\oz_@an P6O0tyηJ=[&"z}֊9nGDp\/U*>b3I7mޜÌcߖF߭C{(^:ҠKHG-| cfgXS'd>Adq LW -tjűc*UFkܪn+KGDlbHK˷$'ԶtDD$tVQ1]>(H)q>1ŅsO2%! IbNS] @a5JEUhm~C޺[UOP3BϙیtU&ɡymLTJ6٤"ފ%~) veR{_UhqNSCfqr>BQl|?SR-p8 Wg rq nlX^,]6ܹb}j4oU=lN aԤc=a_jj8´#us`Wj:ɜ!928n7I' 0jp8 *MIs2dj-U&HR`q Z*hn؁C?p JmDCJI+~Q q9BI-*D1F)hK}OiXm[s^K7m-AgO)0,5Ge# Un.=܅rnn},VJW.61#(lhԷ0 72eڃ8߫ 9“h4ڨ.6CApXާ2k%լqfK:7'fB!dzwaO\UZw 3AE(h6sELX I3Uz8$b?Qw 2Vo㍍]KXl6iMHt@݂Z"jSlqD@31f(G bM-u_1̭%m(U\Mr?Ǭp Ȭ%Tz # 4s(qs7P=D]S[Y]1MPtʺ,ՌU*4C“~L{A<&gNZpF]]16t^I( :N<"&8XY\ #[nL@.wjRuI@xZI}φ"XMQ]~DH2%I]YV*MȌ|D@] @ Q$-HS.{OUN;sM\IlWxS&KnBql:3bi)L|V0#ALB$H4H] +qWGD8:~mIX\#]taaٴO<Kv +.=^!Pb2^as3Lk6gK7vR;CSkfkd'\P=]* @=GYƗUwW(?eIٕF{wlAXk53fT8tS3[fSRM;R/zȞ^QCuT8.Q*2L,8Z>q@*uh:wm1ƻ(̧d!I%?؜.frG$@RF BF9V"vna[PWpHVc-"$aىuqB_ @jFzذ>L=Tb'fd}h{3{VbASPbt@0^12nߨc) @> Yv+dQځ [n3ywY&(xzѮhMN^oRaXNRE I %B(G-c񑛌p ƨsm @3f'UdwJL.`2AM̓ G8YŶ!+j;VJRZap:aD='$~@ pr PBH/. ԘB q؏ ~n$*@oP[p)|Tv0n|).D])u(+/0&ɝ~ݭwU EoZvoD$6MZ"i2hf 6,CQO)D-ĦbX4, A~38V?bXddMXKѳ ڵc#kd:#áDXG$~lBvbL .650 rnsRPXs)hC>T ?-OQIq^OKkYGR=-y)z5XBo4v~ܖ2B3m^Ѻ G}Ta"wׅ "ӽ傖ꖮ9=jCI,5QwX3rYR1P PYyQ|&+\ɴkDDxhVUJ ϰ~|H;LQBX0 __B_˾-]sv&e rF0* _AE/7F mbL|z'x ܹå:YuDkB8шWf/U} -%e=jI GMKd62YKT^\&LL e)`gc@KW?z߻ċ0UWO3ѰY[=PCBFd"JjUjpZL 9-i-ǗtD:J,efyhĤ52$|8faH/a,qa[g\ӊD&y>|`wW)}ͻ+syӞq)rU{jd ".Cԧq,;v:OYuud[y*q3#C) `-6$ŴqH-PL*%R1~qmnOEtÈ_c)Cmtݯ~z,_?wKR;+M ^ppnz~uӣ)-M}+0{9H rى>h6KeL*%WBJzeEFn#? 21UBa !ƵZ cNS}Z8sqh^!ˎXĒ[OAC򲙄rN1s{l)O,f֑8WJ۱ )P3%3EcnQCCOw{JN4QKJ %3s%VAU=ɛ- #4I|>X;Zcs0 @+l@ry"#pTvK YD34B ɤc!HHٱИYѨC/t$vf'8؍~|ڵHjPXPdD70;aͷ1aO5MHi1Ke3v֮7T %!Wq-3J`y;wAe0Oc}Xy=&9ф{ Ļa< ; X.Ob b)KH(̙PCC u-q9ʓ #pJ4(2%v?:OH_ށxŁLfΙ]{x'J >yY nEgl@DG,}9G. k2%$&i%AFB @JXȾk+ '˒-qdBO6D~)Mzpf}f9ƒRYۀ\Nٔ䵤 DXQq`c''/ܭH' ؐ,n}enjN0 ޸֝WTTgM:Bè^1ݥ(1%fWs)hW~qm<=a&&z|10T,"u X. Cr{LXLo\R\2)Xmqkl\dr0y3LGɈ"{DE?6{lN+R 2w@\ֶgw(Y|bmC (<'X,>?BwXQ#Rpd2LϣR*6O )\K;*Dꗷ==,gSe`WWrq;c=BO 4L0\W*¸[5an/o;NvYXP˚x|AU=#<ӂ30{~e6dDA/GLs2M\o ;qfZy*Zd#6H>vH~2_Kզ]ADix[7UBJLgEwA#p%qv{ʍWvc <:Y%z[01Hjqndつ{_UryFadԼ{MEo{e<6d}KrdQFLo%% ײ\9q$vh%;}eV~Z{cN7޳e.cir#RC [̈́t̘Kk`t)'mmky*AzN7񔧌oJ whaὼ0ZEe=2KucfθLMVI* O46Ō2\_]c\Cx I-];i͗Udo4HQ0 -MBw<(z"PkvjCka>fbڌhڗ ͌]jfAcA苲[=ʥDc);1P㸍8e dP<@cIPl@`![{`Sfy> OD*y<&s?zOδ?fMXm>Ga=* F\mO;3|eo=FG5L=rQ*P E!#$LK]K{ۈX)"ƔA' :;ݸ3", YjyCs5;fY m$ĊJOPfgz3P@!Kb>L 0Rm2rIkQ2ҵ]Nl&[&q}G*!2)[ʘ7hHqJs|@@5ݐ!O"{_sϞpUdFX2\X^ɗS\tjy",Q@}2\b)k##sKG*aNJ\ǚ^HqY#'hz/_ ͇7\zbx 7feeHJ3~vɒQ[$emCy[=}G' 1HD/3S1v!sio6IJ1ukqKH$6C ȀR@C0l$i_'QM|`eq *$`4A~RZXrƔ†++e;BT{yKN' SXDžnHY'bKo#׎KŁz.˷8j(d$Hڠ6ӸLH%E1[\r/bquTw!2*~pYk<0/V?,0/ھ/`^ߴ?NZډC$]F(֐f:^ko_|m_:p#}0/YuUh/KtK}~\Q!"92#ث_=6)ƆHn#'zm[_Cu^';s20 Th/r*GjabCrׅ@`=v" ك'iR + ܥkcrAD±d=|Qj[nɸK~r!lVf+7'o[__< ^U ɧ Al!nVҙG2rfHͦ{ *m*r[6~ }4`]\f0mQ/.4_K\c.U=}Tq)"24L1ɻOap#~?e|k ejt8ϔYX1ںЬ 36I_2;wt"6p{Wik{YjW$k<`̚%?m9-S}e _3n2a#ٌ؅>up?|&dۅ}){߶&5 4}~,:BVv@o솰f;(Cد/k@k# X2 Ӱ)3[lhX=ړr䗲_ G^"<ǧxOծU|ҋt>Z<7I )qt䉹h8\uC}Oo p#ZCo9dfjwkoK&faw.Q?u:sU-?և.W?pqrlhu)"%g\+גGo[hy7@:#KFDl5]X+/6eqxӂhyr,вkuJXyA|z.4k˜u<:P@K&2\w}߿'o56ӫJ [j:_kUsGcu|v叻kPWbGcHil!XAblϒ Ɔ[)z{VT\%y3`X_]'Z/jUe!yGOzў/0+_fZ3'}0/E]}m']Ŏ$}R5ȏV,c*!7ۇ+܇#QJ>/%Pz^1P|>Zz;FOX ׍> TT3lڦOՈФbD&aWUv8Tj?L_NkO't9w)%pS1Mg̙_SV+ٸAnHZRqM;Dh ZDe}x5 A~ ʊѴ(:'>tޝm?{Y~}Ehٮet{<_]̞UW3A;R\+8tE]|-@*H*6gi0 S2dۭo<\x+3`)QtiqOoWF4ٓ O,Ǚ41MIG&?އY:PRR >d@Z׸# A T(ֲ:~WGo`#:yede3NYQ_|(=J$+/fM@,Wj<2%|E;& G0%uSm 0CZ:A)Ӥ^g)p|Ʋ6 P@"Cgq {, Is_)Af⿫&he2+Md]flshX*Ph'H2oU05TdO'` &k`-JUEl'sɝ*E ԑߢ)y|}̘`=z zd!Hev[Eε; [''0s,ڇZ(BooCH$o;a3 +pqhNn$njTd掦{L6gBn2.p&Æm[_"-&o1C E~L=,,. ץGǯ,|npCb]:F^!48عYs s3%l!IX^۝8;x*YʕXuH/qO9%NUfI-M.cl9#s_OH6t32fB0 abG24ΘZI:kPXfs ƛ&+PjIJ6hM}$Oe:T~ {WѡnQۈo@5&oKhXGPXy?x.R 'a29J(@41p0g #:n0/"ZA*Ys?# xA @ +n!NF < >kD.ɬ*`43 l*6fqFc.p`!7JSICWЇf9yr#jQݲBiL$X[@m%B`9DcSnAtE@JI!Lb6g`!tm)F0/}B@ S v$󆉆"ᤑ,W,ΈNɟ*.nW`9x7ӓ@?s1|v"ePfe2sh[Sֺ]#g ek1-6o/2HY(T &7 6WR>ŒSq3Њs1i }v<NgeEkUl+S yX`oVY"G6E>0]AؼYY}xb}UJT&񄤜Sj8<`̩<STR ! "'k<j 85f <>> tC H( 8BV@a>֮M-#E*M:0˼];uԃq+fS*_l UHj\t)f#jYњFtUW+ۆi*]ޖ"0;<0 EzQh8M@`KYI3 n8m;V*ps1j4LCH*<5"lrVܐX %UPByayOGDdfwS80 l#hGOqf1LCW?o5$^'2Ё c|=xnygTۋB0>7Xf!Q7n#tSYh0- q3 LK( jE H/o`5- 2O,P8=5~ZkS wmXh}[EݙXF! (> ?:sSl3E֊L n =N, WJU0aB(D1cW0pZ6H3 ^ jDGh, Gag6߄E!g RRFvBGU p5܉ NzrSu uXYnO`y[pD gc5*@y( @${8MH`4G6 p*Sd0HExxIa0{ I&>0ܔl Wh"U*7j)YHBNR)NWpU p鉚/Txq>'|(3R In"&QD?RxRpU pR 0 O` JȄ ŸPK-|R7aQ:)j)hoCg~&Ԋ)Njl+^TMX*E@}yi=޸*)Nk$Uߋ cUu^nQ-/^y7iZT Y}~ߥekW<2C = _%g)Bae ;ZjS|֜d4nƭzY}@PI Jbn"%@hRHRNɨX=݄SC7ߕ`Z/*Ċ_DǟBr)S']&S:?Ǻ5[unS"0r%˩#*t[&GbY%{/unglL2فDᑇ<ٺ^Qш)Ba0ClȨ9J @Y2R~-rԾS`mp<x$^7lX3 ? zRO"W&Qj$%;%M3JK*zee #" Z}-r,̹!=! TeCRMƬT+drCTr䖦:)I'J'R<_#=ȵ^#R/_%Ppa9NCm7)5}'Ҭ&I+?"0heoUH(v RG@n8[ĺ@uo F 1.k/PHyHbD~|%ج0Bh!/SL/$7MGOzC|Sq]vt3u&RS^-eCÀ*A5f`ao!N6 Uv#|Lsg"H ԅQߋs*4G5GCßO=v~DMnDLQABB;2>+9D*~QR* 5 :IW"JF( OT 8N$ 6)5֕Ie+ٲt%IFkG(m2lpKJ* 7a pdJI)_V$Ҋa%9Wꚥ z.Ώ-.>h|Aj#iwH)TmxiL]ީ{)pniiJγp;:'m5 6'+sc|+ ~:8YRjDBOx87mjO*?O1RRP h/.wx7* v"meyؒ$jmPGE\ 3 j83H6 C B`a(WHlCSTnX]H[h/GTmG.e%zq)quأ0?n=TtJ],3yATRXbil &<NIFɮt "m!禫wJ\BzCG +>et1*+"y•e-[˶#=b(: `ZfyA6i{I''˰xm/mEER,cr<ynz]Iƥ2|wt>J5(xYΕ;5 Xet-n*cw6ł+_}PvK Ү^O63ҕ\&sIA(h/؜̝  dGC nv_!8P*oK^ bp2HNeQ5s6Oڷ8c5MͶ?{[9{+uldjmjц"-[^c1.S{{3k}cyw0ӵ7U~l'i+N#`؏Mrꊆ< VQwhr׀<7^d#$7TyRe 9c+N:lDz ֎TrkWdfƎ9r] 5@|`TW!1$ao ʸs)rSX(?u`]&/ \2Q}@f@_;Pq60o;sБZ* ]L`es'ǜ2mDOO=O Ks-.hLSk)?,KR&[O"IڡÛH2xMa#@fc .unǕdߔ ߣ^*48,zwKI%(l@/|yS- (=~l'XrBݰf21ӵT& 1_sRE]CK*MЈ790Wjpm9jW%-TI;l܁9Kt\scqKxx>%]hN)B70wm}b?`]lZ FIa^"{\,lM V_7uea!'5RĄ4کg{nL3ja22P Obn}6H7! ɍh*V:A <,K((LB` OpR`mۮCy>Z‡/3Swq";UoR'A \]ᲀq`&hjuI &VR:7U~FbDXh)7)XGc~߂!%K:X0D`q.Qd@&J>`e r^(+lwYObB-uK MN%.HȆĝ@NΎ)O> 5dmd|/J `Ah y7-K6 ]HBh?d3ԁ!Iv X؉D`no%_*>M(Z0D.ɛt- 纒ُP}45xH0"H*Iڡc]pSF-_a'p>ecMpa9VA;+ǥigcMz1WZ@ XJP]t~7g@g v\&amX:2޲iRHCr׶Hv)-|dY|1܇Cx2[ǹd= MejA) )?umPc2&R nI<+fDXSC}Z%| Έ%utbI|Fo*=%qR}Y>ڨ|"p_ϣӧ77ѐǬiq_-{!GIHNùnI@9H V*"$Cj$^XJ52{B\0׷+)7F} ۹׵6u45ڳLW /-UKmhHGc˺{BbQ>ʑ{&N%2<|9$nƽiz t j qiA4Nz-0 1xt~&MtC^J7fRlpJC_,HIn~=0xq0 ]WI42̽Q~!1>SCU9UTۚe.j0|Bn[YjRyѐa@o̹%֝dXRWO9*3E 6KXj!P mÚB(\uy2򊤴H I+$ dO65o! ̐@AR5vhdf9d l|$pzY?~X0qǕ(0H>Q3X#|r}y$` Ϲݜz+>%Q>O\OȹYi5GR7 ױHt;xr5qH;t&NZeBrPvK>~ӹ}T#,, &6;?>[Vl0zD[!Z{mOINŸ '>"-a h,SA?69aeav-vFA,5>n%L̸M ߺ:*'K؊3LKZs#nD.Nz0v ST"Bx_t0x$32hѤM'>ݸgwC85w=.Te*'lذ[de#~YknBq+#P !‚#RIWnGLB>@+4me&^]nt8PC tSe۸7#f utWta,|F%6벒v.O"w|D]Qu]. uC<fK)*>xgHyTgK>zeO6+ ڙ$XJ" M8g/(8_d~!⑱ ‚oioY@>e9snfTU 8}Rtlz,hpI둋A{OshJvyu@ Q!@JV^̤:uWH4BfFx@acꂇ(&_\kN1TݣPd :Is~T2)ӆe$Mw3G_h%AMS鲙0 ta2"0qoCl* X#l9d`+4aVͽdY-㩰#W(DVAJ"y.sbxz1ԀRdPY.{UPC|$Q@~L#+ -c]TJI,+$Z Uw#Jh?O y#-Ϣƕ_d ŏョ(w>6lΏJUfUt:R0D;FI~ͬОT*TRa, BŊY>U ) \sF ˂uE,Ӻc > h i}C&_i,FMdi2:&  eN cn7cKqiҭ<Ͻ t^G60Kb6N#`Й#x0̓K ]TeI;CkE!J7zmȬ 4DdQy>wW\Kz925-Zfr-eMm L*$uB+ư<>%pǹTn]z$k'~ d1Sm=tw;R-~!*;"pqSKwn&ϠuqCTs6XD6+ A-ƍRڡM#}$3D3w."]%q@FmMjanv~J%?E ;2(FmN]H H]#*RB1vwTP5|tςW9eG>͌s@+$~2[(C3f`^BiGp"WVM>#Իnn_Clr_ViX>\9) H6W:,YOV:+S ex#]sKqjF |GuϏ4D R|]ا6[3NINJ CԪL2bpԒn[dgQJLz3FO]u=6AG:ׅ͐[(9h'D<Az,$ո)l!bz yn[!5[Zn@W\Sg#x"~ ]Z |D_v1W4:TT*b$ԍVV7ͫC?E`ѳDTQh MVSvm[d0aJzJ &͂ܘN)W, @][5=5 K_x{$#v2%(8*HF5(.F/ 6֯Џ?^!_;. AӨǯZx=\x6wF,;:%Y :|MK;t^HI +$"r#4.mk邇H]L;.p,߉t;*$MlCx==%"*K^fffZ{:iP(]uQgk_ltJ;h'E#&-h?i3t$ ˬv_bmhJgZM~h65 }_77"-S9 xz?[3X %޾1ZPHlPK'ڴ&D˳ ۵FgWH YWX8t)wx'[<O|-8|uzrM-MIR+pq huy%5؇&\a /`5& &}3,<'ЮƲ 3'#%) pNr넸]M@6 %Evd5d9A{J]@RoSlFB䄛н5Z:p5t$hj/$c.UBH?K: K$KC!No5wВ2{蓨:4p2F,"O`CH%x;00".#Dcz/^_LD_JLGn O[A5 'pޑ9=-#cͮT nغ0 ΀S<.?@.s`Knf0P4!tMxt&$?<&}Q= CXAybߋ =R"tL0YAlԬpIEAV@`_BΗ(5$Ën!/]`}ZQcKQDUlcIN%o`Yxi^c7?C\d.J%JJ pŀD۩Sۺa x<1YśQ\DUO9MJ |  [qr")BX" iPd h eڀ5UnsMX,zKqTp'RݹNZx<*({ɴCyɰDț6U‹0 t}xiUB$xF :BZcOW+7~fky|d7 N~|K4KI*Tpmz^>; eڷIBٱN={_@@pYQy5: l0\h,\5)6GbјbOsbdoOtN s; }0.iIaxi2>%:QJ W(y- |,qvou5$dR!a $O$ J=WiTȴ"G>xiMЎ)%A<(]+M$i t?76 'IOA(5ʮ<U6TP[tONF!Vcz40|OML3wyi6ҹi3v7`1rdotQ:K]I:K4G `z!3+T(Co{ 0aB+h ɓ|ek[`oO2l˽/KM%!{)삍ћ36O$Ê|DOZrA##q;jP2Ǯ2$ؖ0gv8G2ö}α AG/}e;CxxE2_R1g{6%נ8p^XM;rL/5BB%V ,C.w}jHд! 4VԬȭSQ^CM/2ͯ!|c]S)HBبuk]EQ8xKiz]8q87($OY!b¹ dٓ>Y68ql^C﬐{޿2$p}NvbOal3M~kjZ lJp$0M;tݵLd2r>OVdB^t9<=MVS(쉬o4GR2 P'S#LxFszܷ!MךOX(nefmBgX FR6!?p׌L O/ .5Ƣ!ugI5݀a 0Kk#חi4]$rW1.:H9d5g'kpځxJ=P E^]fD `?jkA)Aa㗭[kRj/̮p0 !Tp>>Z tx5NĔUUMbށ59:͖ 1 +mNU߭fzqMm?YԷMzzzajRIPמl@>4=ܞ&!"6WԌHRFڒMh+B_ A&!8ͼh`Fhp!/^lXnۢth <ؿP&/H?Z jtL>{a&#[ٜm'P^'\OEvʪ,̦ 7r [Ÿ?pMn0XJ0AuI zn [#׉rmnz"-RA&hT8#^/ܖaܛlGQ:\gcD/Ya q' P]|#L86k sjؽ MJdu=)SuO*n I>@sS=?FDo+-ڪ MB d.wQ@פVt:c+c)ZV&in&/R+?X|=(`@e7wD6^j|jVMg͸ tnjlfdj<`v>fCawQUodS8uљ% Ч*0,Ld:!{A%trMj=BT 8V78H7̽L!؍+rs6IPyz1Y*w&IaYՙ:n5]13MHĉ ̠#"&М>/10jP-WVƁjf{-̇?U @|BQ8:X ,8i@(H7c<7YL;tKyb^D藦pfPц%.@e@NWƾwfd\`Wzw":wБ Zt~o }'f` ˡ/~]3E%磄ޏSK?;ٙ +A]STI-hjCm^+In@$2 ˤ}@;ǀ_CB }xz&ֺ05g/=iW#{i4Fk q}-$3M$'>C0=nP `ld˃7<$rOUDd̞5&\()ç~+A %0CZpTDb$#ٞ:'nyv@Ae4ݕ\zqDIJ6@.T^oOJEkx]&F9wXPXv6=ɕߩ>m[$mGw(KSQX5TJJ e%1h92zK| f66QonA{BA .47Ai hLfJj?2J6/ 2C;?mTP#g:J")s#;l`g }9uUk<0uY|D~X%OyG&,"qi0wVv܀6Ɖ΃(L̀3^%$bCOV=v%Hn *8.XBWF X.݉ >^a64 g"B=FXj56Dqy+ɘKʵ9Z5#J;x6@=2Ƌϕ{`[(KSQ7j6TA_7㜐sXa1 8 Y˜3x 2JqocKܓY KZWzk˦8*>;ϲTν8cs-rFp{(݋m(%+{1J,ui [ V5L0,F݃'(^3N>\%b+W^e}cd)Ȟ@1@IH7h~t6Y5^6OVA?5f9Q*UAv&F)>K]3Iw#xW0dN#ŹUl4v@]6Бx `"ږi?aOAf ap!v ЇJ`!駱Xd7He9:^1Jfwٌn/xͬ^5PUo6 /3 ĝ@r]a$0??d@ W-X!|El 0x;n3l)@LL$- V |ǒGOv=} u18Ue(mm r3y=Hئ+=# \,ieN|^.>8:gnNXնkP+ꄭѤ@7Tnk0R:o7f<}jT =`|52 2:| h%Q=~d CŎCJpTt WO(.7M΃pw~ɷ71> (BEsc'NWc陕I /%@܂ _I>ؙέ*U؄'`Cݼ S^XADcp9qs +;EȧF h)$C-ۤL.( V1'ln.B^ֶ&{ziV>mZ_C'DZQ쨃NO ڠhEf#)&[ʖDfj6v+(ݮɮJ5q$ʷ+՚H?ƞWhyn# .0TGL)I ;eaCKyhw]ڮ+'梣i/ bn_Vr)D=Πc Op&z "&Jy!KJ34' ])6жm*WOLDdPw[K<=,uO{A} [o>Y<ؽ19aypUB=ؤVL- 4 ?O\i&77&TY]0R[o mDM"WbP~XHPB"}?/eh΃YU~򐃭R`- W:tʫ+Xy݂Mj C!-O;s{(`"P2z}ZK=*[5 u wHWF4C& !b4^ ! 4 WSsl&)Vz4$SPE09Z uv 쏺L M dfx9ᣎSyܒںV']`!x,nIT37\uWtd.!hZK J'[pٿ_Kfq3. $.uY("1t֖@\thtx N=m4S _7 Uχq TG{|\k8Tz>P@GK:.sXDu6dtW-TIHFŒpStxKwQLIȫv^j~ Iv^k\Mm%tcZ\<rLrӵuh^ 0 ""э}^gX]4W("orPP|>-d޳ڎO" 1KN6W)(f6O^6WHnƍ~ 4(,v;}DZT;Jνܸ 4yt6Ûnjgg,lBoMjEURjjrT3=#&x727P1Q45<' gA4Vz=8?,.σ<ݨ,ќulZ,:Dxx>C ψ2ӣQo"`ۮHe0mgι8kL`y5.7p|lFBTz`s=Р\,s[ fz_4jxYP8aWNJF?HN2hZJNf+.dϧg γdN밊-ı32_6Sϛi$UT`";ZE<'IRӠWPø?_,pck~d=kCaQfct=iNP̹g ؑް@(%u&_an = VIR ;Y[R$-IJ+r97gv0,'_b& 0@WP/ U ܳ\I=UvPX7By@VJ0_M?%H❐mTMsFr%PK&hM?|Fg >]K_=&ep(Y4^eL;DEfJ:lH ',f(/~`-Tb"̨[uIᨅ'r3o\dB6œ{ʭGjGlY0Y!؞_Kh*z,Dqb><-RAPQ CNfܱ-a Bl o["66O_r{HF>V٩қAzI~UuH{C O? ?ʀU!σH。^=v"O4_&Q(m+#T: !#0I@>c*ny&iz$gGB7lyu**.LO*1k-K2[L R"fT v誺Q,\BIb$!"" p 1!D_d.0يS2h`Jc^~I1<j6(\UAޑl` x>`StUIΡ6oB%H cF! p3baW"Zk&JUHL*teU:%[]Iby[0[z}CBP ;ռ/|]#Uks\ Q_: ~g953r9~B2_R 2PKAQ318.7qio,x"QH . zŢpZ[(PAymAH1dE`LmA»X-PɂbB?}sҿ3yrLz:A䛍 Q!P}-j{aYs*kQP?L_o %;W+\ }:*AϾA˳Q[-L  F:YC O9е.(k(*<:lҳzs/5TP}ڧp)F,끴 po½c![|*kg.FP'`xrOL&eݾ] a0scR %] 75B3xKiIB6l9ym ug%p$ {9z@WRP H!]P_ #7Rw:R%8y|16}- Aø#EU8#o´OUD5!LT=v2+'gG˭H!LJg0:s߱]E 8?]*xtC9[_" Cbpuڷ[9sqIMr 5I2o6"NY~H621\$ւs{a .rE)o `"hDa5KsT1.b81 $B{ȏEN;t:hXkRjq fCPw#㞄H38/YY4?=PX&@E+`aIhrLR_p-M4P!- *I t:=}pD۷9&th| %-%[$HZ&R 'pCK܋+'nǺfӯH6*r3bJ%(e. }kb:߁X gvɇ:F-HMZO.;6=}!K;tCu>xi<hӈ"E~_;)cl`GlE;+b[Ӎ<*g:40*0C|YC3r[IQI\)϶A|ej?=^TjP]9B$.H!Y,ƶ=?, ꫿07U">3գ`䐀:2-*/5uِ4tK}ErNj8ʴOSkʌ AaMs2^ֵ8Nd^Ih>2BQ+MaQ'dl^tuϽj姟WEd9GGΘIχѠ|E#lHX+G֑exR nGnOB B6!{xGq"'QSOϦj̋tC3dz9A[ 7jI`Ah{${9+f"oBwWQ'c<s[3w?1}4S'ԷRdFנfFI䈒VLSӯBP:ksx .+ Mæn-c(_&o۾1\áb7'[^%,qWj25%w2uzO"H_%ˌhfEZf:hr2-2\@gwʓ ^l^K%ەLCׇuk+O'6}F;䔷|DcN>ywt.Ќ=۴5e>quvќO=ClHs'Bu5p[. AA2R %8DU)LDǵ߬upkwQ0:jO/O&F`Ƌz4-Eql tAa/F\Cqcת^9cz :M%/!\}ji+V!#̿r+]:@pf:`@o= ;I3!#x^Ο11~k#+Kl@wWb7?;i ZUXex|Mv&DL>I^~4{TDD}"ҼH[-;x51X= ^=~ {K7fMtD2S| |àj`G^`knlln+a/T2(ȝ*߷E0yqܘV< .?BBܩ}IgSK+4Z9yȺQ겱hTI<4A|cfm0O'Jpr['?%_ہ߆.XǗ;~/Qý OA<^w)qFH6hѽNSm^2 -մ÷OErJq3? 8 MlvlC~,,rb\v#\M]9 %4:񽿄m-ï,*8* 8&2~ؖgAݮh_i(Ot|ye>kB۽ ;1-imBXօ2p:n/<Ьd7)VkJ f y@i=ْQd6- la k@lm7F*vWV/C'KM;h`熌0W~Dfh|#뢩b?WКyId['>QnkˆىDى<7*⛀\ ߇>S~Xʂ;S(xy}ޯ? 1 }wX {i^ ){/i5v*#Ja&Tpy(մoAXC屒6BjВD+Ne1߅gkQP/rrմ"Фªȷ2u<>B6J$/Tr.$(=??)(e%!S4k,.uT'PvdiS8OڔoI=ܸ 3t4A'V:Tgq"6ΙTPpw#˖*X<1KEvTiAs`j ;P5){=k+LlJ܉=b΁ej j5XXSdU˂().be/H"s,L{ƾQ]ֵ.x_OJ$cb*PwIcuK(zѩRRÅ_AfXu,x!ǁaρzI $N[B>J3)?uFbUy%i3UhhͼxlݤMeqϦJ^s)f5ow-`%uBFt݇]ў!Vh_rb=u%7b&ߕǻ"q1HMz=~p0x3[4'-EAtR&Z}NG͂e, Np%9?X߫^ގOKǾ{pYv#$E:#gҠ!2u<),xj{yZRʄDF)˝6֍W88JqAHJgbP6)7U}ȷ!h lEB Dv. PT/ج |Ϙb૪niܖ-H滩cdgl6ģSk ??w8 KTC3L}Gs/3vU>g*}Cj2ysDMuBv)iL[Z|Azm4w"08$!t.k76xC$Ln`Tp'>Jv6:G:_)M QbC+Af}ãP7$iz3;_t.\yQZᜁѹ˨Q$)e]#|sEG1׫|~%KCvŸ܆KKgrl'䴽;=ȵ;0'.: .P,x a83>xA={lJmF5h_?N~)~O /$(n9g:& ⡣Yn".B ܹ+7Mҡ2tP @l.r/k &vڿl0ͫ0k'`:,b|I V8&\ Px ob]H)<%G7*ڭ^|{Sfj)#5.vqcKbD"UN0a͋>u]sS p y*3QyERS-'[OEuSem0Y&BĠD0*0yq".v.WY#~|y)r;4Cq&4{°Eb4D:x|$#Zi&+_\ 3@$AXP~Cxd_Z0eFkskߜ&|L^D\SZ [;;I҃B׌V1A,l!@]$ޣ2NB2tlQBIjC v B\ ^T3O hj2olm.MAD AF-ڗOjy EBd@;L=G'^oHq\{WMAD[觥zZF{_s׶kjGgL?[.( 4fawbvՋvgyxQSɆe x&LvZ,o7BhN|Ħ{A`#J!"@{a7B :v Ǭ;wD6ry]\>$V1 Ӽzd9D&xfÂ5 5TGnPV, E&/}dipMh΃y?tE1L 7_1pJ`__83V &\_4-8j`c¼˜Cw -21w6P*zL_'uNCFn4J(pHCꓼ>|@KtZ&9qk%"Z?t/twBCq/ q(l&f 5CZ5О AuNJ#j}d$RxadvrM~LEL v;!gC%AA!n3VJPNCvq4O>}e#A>L׋*?pW[l/^xgz';kiEӆViîΝ(/0# (/kٿ[Qg.HT!DlCT+VdS1C|:5|>zjB" ZG@I_Nvubq4R`H/h.xc(~.}i#% z{B=Yn3vŋ,ô!Nt:,o;d:bpgѴfC#4K̟!0ccj?1zt" hģd[&e]>CqDT=16C/)'uuIJNȄDzdC>|z0Z:NZe EBG ۥs҃$$-McA ߷"5q^W5jq>_bDh.C`ia/ 2d!bĈi5|@N<X\("Z3A w cx4߾2Rv3QIGjI4Iκnt3V\@Ҽ`F|S@.CI(H6ZT&i+9ޝˉX\&rFFDe'HF, oA:.ȓP_4bJtZ+6Jź!>1G4}oF9tʾC }"V~ټX2ziHOU4.V4^Hg%l CC?<. *',4Ws֗TTN9$MA1\= t it ph@%?"ކ X|h(,c(8 a\;tP?@~=}ϱQh1ċNf<#rKn6Xk'GմQ\y qN2R{?'{bšo8Q(F"zLT0"Gx:ԤBXċNӛH7at8픺Nli̷Ls&ŭ2/;QxXIB|*v.Rǿ |8M^[o8Q05':"B' Ö'M{ASo,p Om  Byt-.xșm5uӏh֐j0q0 _U_Xp)eH h ?L-q;Nbbs? W$yE9S0@:C[e^FÄ BΤIRsL1@g,h:>`紡_Aa8>7hraUw2gjRiv w 6ߔ:-yt-/iңxԅ5,w !X5ߐu߷V=y.\靟kIo}5~CeV" 9KAi<>`3wt ws<#z8/>f][.i6=|`ՈB3#PD,eѢ%؜)< vdĢ F \-zC)xÑ> >#T RS"Sۑdn:1W-4]U҃7/ \Rؙ: Bw%P fI楅k*<Q[&EF:ӢLݪ5Gu8lHH~ Zٴ)B_5}}{"֗xa4 a>]K6 6Ș `;dD滝mi]fJw&WӠoi1O6I6mfZꭣi?r!{  M0i <<ݟ&<}6Oiq)8`Oĥ&?ճO + z0Gfd4 |zs+dތsJ[_Rሑ7f*O bF89ʸ`9$&{0٤a^8pP= hSpH%Y|eR)%PiYiK"{ǶDls2Pp5D-nM(UD=B Un֡2E,ϡct"I~E(XԴ@Bj1^]cYnȣ)@n4u E"Ue4^d6t E&,1 ^ QgYzr,35! p=pu1{*%9?} S1B$NP`S8Lt!`f qn A0A$#s1'B>`T.Ei_0Pi9>X%\2q)8Wl** ]B5?s A`ơ! &