"
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"
for arch in armv5l armv6l armv7l arm64; do
build "linux" "$arch"
done
(
cd "$d"
sha256sum -c --strict *.sha256
)
go-tools-2021.1.2/doc/ 0000775 0000000 0000000 00000000000 14143223131 0014241 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/doc/2017.2.html 0000664 0000000 0000000 00000013360 14143223131 0015663 0 ustar 00root root 0000000 0000000 Introduction to staticcheck 2017.2
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.
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:
{
"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
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
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
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.
go-tools-2021.1.2/doc/2019.1.html 0000664 0000000 0000000 00000020216 14143223131 0015662 0 ustar 00root root 0000000 0000000 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 -<tool>.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 β -<tool>.enabled flags.
Details on all of the command-line flags can be found in the documentation.
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 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 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 -<tool>.enabled and -<tool>.exit-non-zero
have been replaced by -checks and -fail.
Finally, the -ignore flag has been replaced
by linter directives .
Binary releases
Beginning with this release, we're publishing
prebuilt binaries to GitHub .
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
(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
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.
go-tools-2021.1.2/doc/2019.2.html 0000664 0000000 0000000 00000044154 14143223131 0015672 0 ustar 00root root 0000000 0000000
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
Part of the redesign of staticcheck involved porting our code to the 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
We've made several minor improvements to the command-line interface of staticcheck that improve usability and debuggability.
SIGINFO handler
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.
Packages: 37/619 initial, 38/1011 total; Workers: 8/8; Problems: 73
Explaining checks
Using the new -explain flag, a check's documentation can be displayed right in the terminal,
eliminating the need to browse to https://staticcheck.io/docs/checks .
$ 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
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.
$ 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
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
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
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@<version>,
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
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 .
This release no longer includes these deprecated utilities, nor does
it provide the deprecated flag.
Checks
New checks
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 ,
which take the form of if 42 == x.
{{ check "ST1018" }} flags string literals containing zero-width characters.
Changed checks
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
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 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 ,
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.
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
for
$250 USD a month ,
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 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
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
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 -<year>.<minor> instead of v0.0.0 -<year>.<minor>.
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
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.
go-tools-2021.1.2/doc/2020.1.html 0000664 0000000 0000000 00000027016 14143223131 0015657 0 ustar 00root root 0000000 0000000
Introduction to Staticcheck 2020.1
Staticcheck 2020.1 introduces UI improvements, speed enhancements, and
a number of new as well as improved checks. Additionally, it is the
first release to support the upcoming Go 1.14.
UI improvements
We've improved the output of the staticcheck command as well as
Staticcheck's integration with 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:
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:
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 textstylishjsonrelated 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
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
New checks
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
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 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
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
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
The 2020.1.1 release incorrectly identified itself as version 2020.1.
Staticcheck 2020.1.3 release notes
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
This release adds special handling for imports of the
deprecated github.com/golang/protobuf/proto package.
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 .
Staticcheck 2020.1.5 release notes
This release fixes a crash in the pattern matching engine
and a false positive in SA4006 .
Staticcheck 2020.1.6 release notes
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.
go-tools-2021.1.2/doc/2020.2.html 0000664 0000000 0000000 00000042740 14143223131 0015661 0 ustar 00root root 0000000 0000000
The primary focus of this release is a major improvement in performance, significantly reducing memory usage while also reducing runtimes.
Benchmarks comparing the previous and current releases of Staticcheck
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
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
Removal of whole-program mode and changes to the handling of exported identifiers
The aforementioned 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
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
package pkg
//lint:ignore U1000 This is fine.
func fn1() { fn2() }
func fn2() {}
Staticcheck would emit the following output:
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
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
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-<human version> 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>.<patch>.
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 .
Checks
New checks
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
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
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 article by the Go authors for more information on this potential vulnerability.
Staticcheck 2020.2.2 release notes
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
This release fixes a false positive in U1000. See issue 942 for an example.
Staticcheck 2020.2.4 release notes
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 and
981 for more information)
A rare crash (see issue 972 for more information)
go-tools-2021.1.2/doc/2021.1.html 0000664 0000000 0000000 00000013653 14143223131 0015662 0 ustar 00root root 0000000 0000000
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
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
New checks
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
{{ 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
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
The documentation on the website 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
Several behind the scenes changes prepare this release for better integration with gopls .
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
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 ) has made rdeps redundant.
Staticcheck 2021.1.1 release notes
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 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.
go-tools-2021.1.2/doc/articles/ 0000775 0000000 0000000 00000000000 14143223131 0016047 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/doc/articles/customizing_staticcheck.html 0000664 0000000 0000000 00000000313 14143223131 0023652 0 ustar 00root root 0000000 0000000 - 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
go-tools-2021.1.2/doc/configuration.html 0000664 0000000 0000000 00000023146 14143223131 0020004 0 ustar 00root root 0000000 0000000
Configuring Staticcheck
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
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).
Targeting Go versions
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 that it was compiled with.
If your project needs to support older versions of Go, you can use the -go flag to overwrite this, for example by saying staticcheck -go 1.14.
Excluding 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.
Much like go, staticcheck accepts the -tags flag to specify the active build tags.
Staticcheck can format its output in a number of ways, by using the -f flag.
See this list of formatters for a list of all formatters.
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:
.
βββ 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.
Staticcheck configuration files are named staticcheck.conf and contain 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.
Currently, this is only used when enabling 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
A list of all options and their explanations can be found on the Options page.
Example configuration
The following example configuration is the textual representation of Staticcheck's default configuration.
{{ option "checks" }} = ["all", "-{{ check "ST1000" }}", "-{{ check "ST1003" }}", "-{{ check "ST1016" }}", "-{{ check "ST1020" }}", "-{{ check "ST1021" }}", "-{{ check "ST1022" }}", "-{{ check "ST1023" }}"]
{{ option "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"]
{{ option "dot_import_whitelist" }} = []
{{ option "http_status_code_whitelist" }} = ["200", "400", "404", "500"]Ignoring problems with linter directives
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
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:
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:
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
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
//lint:ignore SA1000 we love invalid regular expressions!
regexp.Compile(".+")
Staticcheck will report the following:
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
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:
//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.
go-tools-2021.1.2/doc/formatters.html 0000664 0000000 0000000 00000004515 14143223131 0017322 0 ustar 00root root 0000000 0000000
Text
Text is the default output formatter.
It formats problems using the following format: file:line:col: message.
This format is commonly used by compilers and linters,
and is understood by most editors.
Example output
go/src/fmt/print.go:1069:15: this value of afterIndex is never used (SA4006)Stylish
Stylish is a formatter designed for human consumption.
It groups results by file name
and breaks up the various pieces of information into columns.
Additionally, it displays a final summary.
This output format is not suited for automatic consumption by tools
and may change between versions.
go/src/fmt/fmt_test.go
(43, 2) S1021 should merge variable declaration with assignment on next line
(1185, 10) SA9003 empty branch
go/src/fmt/print.go
(77, 18) ST1006 methods on the same type should have the same receiver name (seen 3x "b", 1x "bp")
(1069, 15) SA4006 this value of afterIndex is never used
go/src/fmt/scan.go
(465, 5) ST1012 error var complexError should have name of the form errFoo
(466, 5) ST1012 error var boolError should have name of the form errFoo
β 6 problems (6 errors, 0 warnings)
JSON
The JSON formatter emits one JSON object per problem found β
that is, it is a stream of objects, not an array.
Most fields should be self-explanatory.
The severity field may be one of
"error", "warning" or "ignored".
Whether a problem is an error or a warning is determined by the -fail flag.
The value "ignored" is used for problems that were ignored,
if the -show-ignored flag was provided.
Example output
Note that actual output is not formatted nicely.
The example has been formatted to improve readability.
{
"code": "SA4006",
"severity": "error",
"location": {
"file": "/usr/lib/go/src/fmt/print.go",
"line": 1082,
"column": 15
},
"end": {
"file": "/usr/lib/go/src/fmt/print.go",
"line": 1082,
"column": 25
},
"message": "this value of afterIndex is never used"
}
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.
The following articles will help you get started:
go-tools-2021.1.2/doc/install.html 0000664 0000000 0000000 00000004105 14143223131 0016575 0 ustar 00root root 0000000 0000000 Installing Staticcheck
tl;dr
Install honnef.co/go/tools/cmd/staticcheck@latest.
From source
Beginning with Go 1.16, 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 .
Binary releases
We publish binary releases for the most common operating systems and CPU architectures.
These can be downloaded from GitHub .
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 the latest version in a timely manner.
What follows is a non-exhaustive list of the package names in various package repositories.
Arch Linux
staticcheck Debian
golang-honnef-go-tools-dev Fedora
golang-honnef-tools Homebrew
staticcheck MacPorts
staticcheck NixOS
go-tools
go-tools-2021.1.2/doc/options.html 0000664 0000000 0000000 00000004071 14143223131 0016624 0 ustar 00root root 0000000 0000000
checks
This option sets which 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", "-ST1003 "]
initialisms
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"]
dot_import_whitelist
By default, 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
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"]
go-tools-2021.1.2/doc/run.html 0000664 0000000 0000000 00000002732 14143223131 0015737 0 ustar 00root root 0000000 0000000 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.io/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.
go-tools-2021.1.2/go.mod 0000664 0000000 0000000 00000000156 14143223131 0014604 0 ustar 00root root 0000000 0000000 module honnef.co/go/tools
go 1.14
require (
github.com/BurntSushi/toml v0.3.1
golang.org/x/tools v0.1.0
)
go-tools-2021.1.2/go.sum 0000664 0000000 0000000 00000005326 14143223131 0014635 0 ustar 00root root 0000000 0000000 github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4=
golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4 h1:myAQVi0cGEoqQVR5POX+8RR2mrocKqNN1hmeMqhX27k=
golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.1.0 h1:po9/4sTYwZU9lPhi1tOrb4hCv3qrhiQ77LZfGa2OjwY=
golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
go-tools-2021.1.2/go/ 0000775 0000000 0000000 00000000000 14143223131 0014101 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/go/ast/ 0000775 0000000 0000000 00000000000 14143223131 0014670 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/go/ast/astutil/ 0000775 0000000 0000000 00000000000 14143223131 0016355 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/go/ast/astutil/upstream.go 0000664 0000000 0000000 00000000656 14143223131 0020553 0 ustar 00root root 0000000 0000000 package 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)
}
go-tools-2021.1.2/go/ast/astutil/util.go 0000664 0000000 0000000 00000015325 14143223131 0017667 0 ustar 00root root 0000000 0000000 package astutil
import (
"fmt"
"go/ast"
"go/token"
"reflect"
"strings"
)
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 == "_"
}
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
}
}
func CopyExpr(node ast.Expr) ast.Expr {
switch node := node.(type) {
case *ast.BasicLit:
cp := *node
return &cp
case *ast.BinaryExpr:
cp := *node
cp.X = CopyExpr(cp.X)
cp.Y = CopyExpr(cp.Y)
return &cp
case *ast.CallExpr:
cp := *node
cp.Fun = CopyExpr(cp.Fun)
cp.Args = make([]ast.Expr, len(node.Args))
for i, v := range node.Args {
cp.Args[i] = CopyExpr(v)
}
return &cp
case *ast.CompositeLit:
cp := *node
cp.Type = CopyExpr(cp.Type)
cp.Elts = make([]ast.Expr, len(node.Elts))
for i, v := range node.Elts {
cp.Elts[i] = CopyExpr(v)
}
return &cp
case *ast.Ident:
cp := *node
return &cp
case *ast.IndexExpr:
cp := *node
cp.X = CopyExpr(cp.X)
cp.Index = CopyExpr(cp.Index)
return &cp
case *ast.KeyValueExpr:
cp := *node
cp.Key = CopyExpr(cp.Key)
cp.Value = CopyExpr(cp.Value)
return &cp
case *ast.ParenExpr:
cp := *node
cp.X = CopyExpr(cp.X)
return &cp
case *ast.SelectorExpr:
cp := *node
cp.X = CopyExpr(cp.X)
cp.Sel = CopyExpr(cp.Sel).(*ast.Ident)
return &cp
case *ast.SliceExpr:
cp := *node
cp.X = CopyExpr(cp.X)
cp.Low = CopyExpr(cp.Low)
cp.High = CopyExpr(cp.High)
cp.Max = CopyExpr(cp.Max)
return &cp
case *ast.StarExpr:
cp := *node
cp.X = CopyExpr(cp.X)
return &cp
case *ast.TypeAssertExpr:
cp := *node
cp.X = CopyExpr(cp.X)
cp.Type = CopyExpr(cp.Type)
return &cp
case *ast.UnaryExpr:
cp := *node
cp.X = CopyExpr(cp.X)
return &cp
case *ast.MapType:
cp := *node
cp.Key = CopyExpr(cp.Key)
cp.Value = CopyExpr(cp.Value)
return &cp
case *ast.ArrayType:
cp := *node
cp.Len = CopyExpr(cp.Len)
cp.Elt = CopyExpr(cp.Elt)
return &cp
case *ast.Ellipsis:
cp := *node
cp.Elt = CopyExpr(cp.Elt)
return &cp
case *ast.InterfaceType:
cp := *node
return &cp
case *ast.StructType:
cp := *node
return &cp
case *ast.FuncLit:
// TODO(dh): implement copying of function literals.
return nil
case *ast.ChanType:
cp := *node
cp.Value = CopyExpr(cp.Value)
return &cp
case nil:
return nil
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.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))
}
}
go-tools-2021.1.2/go/callgraph/ 0000775 0000000 0000000 00000000000 14143223131 0016036 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/go/callgraph/callgraph.go 0000664 0000000 0000000 00000007312 14143223131 0020325 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 callgraph defines the call graph and various algorithms
and utilities to operate on it.
A call graph is a labelled directed graph whose nodes represent
functions and whose edge labels represent syntactic function call
sites. The presence of a labelled edge (caller, site, callee)
indicates that caller may call callee at the specified call site.
A call graph is a multigraph: it may contain multiple edges (caller,
*, callee) connecting the same pair of nodes, so long as the edges
differ by label; this occurs when one function calls another function
from multiple call sites. Also, it may contain multiple edges
(caller, site, *) that differ only by callee; this indicates a
polymorphic call.
A SOUND call graph is one that overapproximates the dynamic calling
behaviors of the program in all possible executions. One call graph
is more PRECISE than another if it is a smaller overapproximation of
the dynamic behavior.
All call graphs have a synthetic root node which is responsible for
calling main() and init().
Calls to built-in functions (e.g. panic, println) are not represented
in the call graph; they are treated like built-in operators of the
language.
*/
package callgraph
// TODO(adonovan): add a function to eliminate wrappers from the
// callgraph, preserving topology.
// More generally, we could eliminate "uninteresting" nodes such as
// nodes from packages we don't care about.
import (
"fmt"
"go/token"
"honnef.co/go/tools/go/ir"
)
// A Graph represents a call graph.
//
// A graph may contain nodes that are not reachable from the root.
// If the call graph is sound, such nodes indicate unreachable
// functions.
//
type Graph struct {
Root *Node // the distinguished root node
Nodes map[*ir.Function]*Node // all nodes by function
}
// New returns a new Graph with the specified root node.
func New(root *ir.Function) *Graph {
g := &Graph{Nodes: make(map[*ir.Function]*Node)}
g.Root = g.CreateNode(root)
return g
}
// CreateNode returns the Node for fn, creating it if not present.
func (g *Graph) CreateNode(fn *ir.Function) *Node {
n, ok := g.Nodes[fn]
if !ok {
n = &Node{Func: fn, ID: len(g.Nodes)}
g.Nodes[fn] = n
}
return n
}
// A Node represents a node in a call graph.
type Node struct {
Func *ir.Function // the function this node represents
ID int // 0-based sequence number
In []*Edge // unordered set of incoming call edges (n.In[*].Callee == n)
Out []*Edge // unordered set of outgoing call edges (n.Out[*].Caller == n)
}
func (n *Node) String() string {
return fmt.Sprintf("n%d:%s", n.ID, n.Func)
}
// A Edge represents an edge in the call graph.
//
// Site is nil for edges originating in synthetic or intrinsic
// functions, e.g. reflect.Call or the root of the call graph.
type Edge struct {
Caller *Node
Site ir.CallInstruction
Callee *Node
}
func (e Edge) String() string {
return fmt.Sprintf("%s --> %s", e.Caller, e.Callee)
}
func (e Edge) Description() string {
var prefix string
switch e.Site.(type) {
case nil:
return "synthetic call"
case *ir.Go:
prefix = "concurrent "
case *ir.Defer:
prefix = "deferred "
}
return prefix + e.Site.Common().Description()
}
func (e Edge) Pos() token.Pos {
if e.Site == nil {
return token.NoPos
}
return e.Site.Pos()
}
// AddEdge adds the edge (caller, site, callee) to the call graph.
// Elimination of duplicate edges is the caller's responsibility.
func AddEdge(caller *Node, site ir.CallInstruction, callee *Node) {
e := &Edge{caller, site, callee}
callee.In = append(callee.In, e)
caller.Out = append(caller.Out, e)
}
go-tools-2021.1.2/go/callgraph/cha/ 0000775 0000000 0000000 00000000000 14143223131 0016571 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/go/callgraph/cha/cha.go 0000664 0000000 0000000 00000010270 14143223131 0017653 0 ustar 00root root 0000000 0000000 // Copyright 2014 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 cha computes the call graph of a Go program using the Class
// Hierarchy Analysis (CHA) algorithm.
//
// CHA was first described in "Optimization of Object-Oriented Programs
// Using Static Class Hierarchy Analysis", Jeffrey Dean, David Grove,
// and Craig Chambers, ECOOP'95.
//
// CHA is related to RTA (see go/callgraph/rta); the difference is that
// CHA conservatively computes the entire "implements" relation between
// interfaces and concrete types ahead of time, whereas RTA uses dynamic
// programming to construct it on the fly as it encounters new functions
// reachable from main. CHA may thus include spurious call edges for
// types that haven't been instantiated yet, or types that are never
// instantiated.
//
// Since CHA conservatively assumes that all functions are address-taken
// and all concrete types are put into interfaces, it is sound to run on
// partial programs, such as libraries without a main or test function.
//
package cha
import (
"go/types"
"honnef.co/go/tools/go/callgraph"
"honnef.co/go/tools/go/ir"
"honnef.co/go/tools/go/ir/irutil"
"honnef.co/go/tools/go/types/typeutil"
)
// CallGraph computes the call graph of the specified program using the
// Class Hierarchy Analysis algorithm.
//
func CallGraph(prog *ir.Program) *callgraph.Graph {
cg := callgraph.New(nil) // TODO(adonovan) eliminate concept of rooted callgraph
allFuncs := irutil.AllFunctions(prog)
// funcsBySig contains all functions, keyed by signature. It is
// the effective set of address-taken functions used to resolve
// a dynamic call of a particular signature.
var funcsBySig typeutil.Map // value is []*ir.Function
// methodsByName contains all methods,
// grouped by name for efficient lookup.
methodsByName := make(map[string][]*ir.Function)
// methodsMemo records, for every abstract method call call I.f on
// interface type I, the set of concrete methods C.f of all
// types C that satisfy interface I.
methodsMemo := make(map[*types.Func][]*ir.Function)
lookupMethods := func(m *types.Func) []*ir.Function {
methods, ok := methodsMemo[m]
if !ok {
I := m.Type().(*types.Signature).Recv().Type().Underlying().(*types.Interface)
for _, f := range methodsByName[m.Name()] {
C := f.Signature.Recv().Type() // named or *named
if types.Implements(C, I) {
methods = append(methods, f)
}
}
methodsMemo[m] = methods
}
return methods
}
for f := range allFuncs {
if f.Signature.Recv() == nil {
// Package initializers can never be address-taken.
if f.Name() == "init" && f.Synthetic == ir.SyntheticPackageInitializer {
continue
}
funcs, _ := funcsBySig.At(f.Signature).([]*ir.Function)
funcs = append(funcs, f)
funcsBySig.Set(f.Signature, funcs)
} else {
methodsByName[f.Name()] = append(methodsByName[f.Name()], f)
}
}
addEdge := func(fnode *callgraph.Node, site ir.CallInstruction, g *ir.Function) {
gnode := cg.CreateNode(g)
callgraph.AddEdge(fnode, site, gnode)
}
addEdges := func(fnode *callgraph.Node, site ir.CallInstruction, callees []*ir.Function) {
// Because every call to a highly polymorphic and
// frequently used abstract method such as
// (io.Writer).Write is assumed to call every concrete
// Write method in the program, the call graph can
// contain a lot of duplication.
//
// TODO(adonovan): opt: consider factoring the callgraph
// API so that the Callers component of each edge is a
// slice of nodes, not a singleton.
for _, g := range callees {
addEdge(fnode, site, g)
}
}
for f := range allFuncs {
fnode := cg.CreateNode(f)
for _, b := range f.Blocks {
for _, instr := range b.Instrs {
if site, ok := instr.(ir.CallInstruction); ok {
call := site.Common()
if call.IsInvoke() {
addEdges(fnode, site, lookupMethods(call.Method))
} else if g := call.StaticCallee(); g != nil {
addEdge(fnode, site, g)
} else if _, ok := call.Value.(*ir.Builtin); !ok {
callees, _ := funcsBySig.At(call.Signature()).([]*ir.Function)
addEdges(fnode, site, callees)
}
}
}
}
}
return cg
}
go-tools-2021.1.2/go/callgraph/cha/cha_test.go 0000664 0000000 0000000 00000004762 14143223131 0020723 0 ustar 00root root 0000000 0000000 // Copyright 2014 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/callgraph's test suite is built around the deprecated go/loader. We'll leave fixing that to upstream.
// No testdata on Android.
// +build !android
package cha_test
import (
"bytes"
"fmt"
"go/ast"
"go/parser"
"go/token"
"go/types"
"io/ioutil"
"sort"
"strings"
"testing"
"honnef.co/go/tools/go/callgraph"
"honnef.co/go/tools/go/callgraph/cha"
"honnef.co/go/tools/go/ir/irutil"
"golang.org/x/tools/go/loader"
)
var inputs = []string{
"testdata/func.go",
"testdata/iface.go",
"testdata/recv.go",
}
func expectation(f *ast.File) (string, token.Pos) {
for _, c := range f.Comments {
text := strings.TrimSpace(c.Text())
if t := strings.TrimPrefix(text, "WANT:\n"); t != text {
return t, c.Pos()
}
}
return "", token.NoPos
}
// TestCHA runs CHA on each file in inputs, prints the dynamic edges of
// the call graph, and compares it with the golden results embedded in
// the WANT comment at the end of the file.
//
func TestCHA(t *testing.T) {
for _, filename := range inputs {
content, err := ioutil.ReadFile(filename)
if err != nil {
t.Errorf("couldn't read file '%s': %s", filename, err)
continue
}
conf := loader.Config{
ParserMode: parser.ParseComments,
}
f, err := conf.ParseFile(filename, content)
if err != nil {
t.Error(err)
continue
}
want, pos := expectation(f)
if pos == token.NoPos {
t.Errorf("No WANT: comment in %s", filename)
continue
}
conf.CreateFromFiles("main", f)
iprog, err := conf.Load()
if err != nil {
t.Error(err)
continue
}
prog := irutil.CreateProgram(iprog, 0)
mainPkg := prog.Package(iprog.Created[0].Pkg)
prog.Build()
cg := cha.CallGraph(prog)
if got := printGraph(cg, mainPkg.Pkg); got != want {
t.Errorf("%s: got:\n%s\nwant:\n%s",
prog.Fset.Position(pos), got, want)
}
}
}
func printGraph(cg *callgraph.Graph, from *types.Package) string {
var edges []string
callgraph.GraphVisitEdges(cg, func(e *callgraph.Edge) error {
if strings.Contains(e.Description(), "dynamic") {
edges = append(edges, fmt.Sprintf("%s --> %s",
e.Caller.Func.RelString(from),
e.Callee.Func.RelString(from)))
}
return nil
})
sort.Strings(edges)
var buf bytes.Buffer
buf.WriteString("Dynamic calls\n")
for _, edge := range edges {
fmt.Fprintf(&buf, " %s\n", edge)
}
return strings.TrimSpace(buf.String())
}
go-tools-2021.1.2/go/callgraph/cha/testdata/ 0000775 0000000 0000000 00000000000 14143223131 0020402 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/go/callgraph/cha/testdata/func.go 0000664 0000000 0000000 00000000464 14143223131 0021670 0 ustar 00root root 0000000 0000000 //+build ignore
package main
// Test of dynamic function calls; no interfaces.
func A(int) {}
var (
B = func(int) {}
C = func(int) {}
)
func f() {
pfn := B
pfn(0) // calls A, B, C, even though A is not even address-taken
}
// WANT:
// Dynamic calls
// f --> A
// f --> init$1
// f --> init$2
go-tools-2021.1.2/go/callgraph/cha/testdata/iface.go 0000664 0000000 0000000 00000001703 14143223131 0022001 0 ustar 00root root 0000000 0000000 //+build ignore
package main
// Test of interface calls. None of the concrete types are ever
// instantiated or converted to interfaces.
type I interface {
f()
}
type J interface {
f()
g()
}
type C int // implements I
func (*C) f()
type D int // implements I and J
func (*D) f()
func (*D) g()
func one(i I, j J) {
i.f() // calls *C and *D
}
func two(i I, j J) {
j.f() // calls *D (but not *C, even though it defines method f)
}
func three(i I, j J) {
j.g() // calls *D
}
func four(i I, j J) {
Jf := J.f
if unknown {
Jf = nil // suppress IR constant propagation
}
Jf(nil) // calls *D
}
func five(i I, j J) {
jf := j.f
if unknown {
jf = nil // suppress IR constant propagation
}
jf() // calls *D
}
var unknown bool
// WANT:
// Dynamic calls
// (J).f$bound --> (*D).f
// (J).f$thunk --> (*D).f
// five --> (J).f$bound
// four --> (J).f$thunk
// one --> (*C).f
// one --> (*D).f
// three --> (*D).g
// two --> (*D).f
go-tools-2021.1.2/go/callgraph/cha/testdata/recv.go 0000664 0000000 0000000 00000000656 14143223131 0021677 0 ustar 00root root 0000000 0000000 //+build ignore
package main
type I interface {
f()
}
type J interface {
g()
}
type C int // C and *C implement I; *C implements J
func (C) f()
func (*C) g()
type D int // *D implements I and J
func (*D) f()
func (*D) g()
func f(i I) {
i.f() // calls C, *C, *D
}
func g(j J) {
j.g() // calls *C, *D
}
// WANT:
// Dynamic calls
// f --> (*C).f
// f --> (*D).f
// f --> (C).f
// g --> (*C).g
// g --> (*D).g
go-tools-2021.1.2/go/callgraph/rta/ 0000775 0000000 0000000 00000000000 14143223131 0016624 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/go/callgraph/rta/rta.go 0000664 0000000 0000000 00000034333 14143223131 0017747 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.
// This package provides Rapid Type Analysis (RTA) for Go, a fast
// algorithm for call graph construction and discovery of reachable code
// (and hence dead code) and runtime types. The algorithm was first
// described in:
//
// David F. Bacon and Peter F. Sweeney. 1996.
// Fast static analysis of C++ virtual function calls. (OOPSLA '96)
// http://doi.acm.org/10.1145/236337.236371
//
// The algorithm uses dynamic programming to tabulate the cross-product
// of the set of known "address taken" functions with the set of known
// dynamic calls of the same type. As each new address-taken function
// is discovered, call graph edges are added from each known callsite,
// and as each new call site is discovered, call graph edges are added
// from it to each known address-taken function.
//
// A similar approach is used for dynamic calls via interfaces: it
// tabulates the cross-product of the set of known "runtime types",
// i.e. types that may appear in an interface value, or be derived from
// one via reflection, with the set of known "invoke"-mode dynamic
// calls. As each new "runtime type" is discovered, call edges are
// added from the known call sites, and as each new call site is
// discovered, call graph edges are added to each compatible
// method.
//
// In addition, we must consider all exported methods of any runtime type
// as reachable, since they may be called via reflection.
//
// Each time a newly added call edge causes a new function to become
// reachable, the code of that function is analyzed for more call sites,
// address-taken functions, and runtime types. The process continues
// until a fixed point is achieved.
//
// The resulting call graph is less precise than one produced by pointer
// analysis, but the algorithm is much faster. For example, running the
// cmd/callgraph tool on its own source takes ~2.1s for RTA and ~5.4s
// for points-to analysis.
//
package rta
// TODO(adonovan): test it by connecting it to the interpreter and
// replacing all "unreachable" functions by a special intrinsic, and
// ensure that that intrinsic is never called.
import (
"fmt"
"go/types"
"honnef.co/go/tools/go/callgraph"
"honnef.co/go/tools/go/ir"
"honnef.co/go/tools/go/types/typeutil"
)
// A Result holds the results of Rapid Type Analysis, which includes the
// set of reachable functions/methods, runtime types, and the call graph.
//
type Result struct {
// CallGraph is the discovered callgraph.
// It does not include edges for calls made via reflection.
CallGraph *callgraph.Graph
// Reachable contains the set of reachable functions and methods.
// This includes exported methods of runtime types, since
// they may be accessed via reflection.
// The value indicates whether the function is address-taken.
//
// (We wrap the bool in a struct to avoid inadvertent use of
// "if Reachable[f] {" to test for set membership.)
Reachable map[*ir.Function]struct{ AddrTaken bool }
// RuntimeTypes contains the set of types that are needed at
// runtime, for interfaces or reflection.
//
// The value indicates whether the type is inaccessible to reflection.
// Consider:
// type A struct{B}
// fmt.Println(new(A))
// Types *A, A and B are accessible to reflection, but the unnamed
// type struct{B} is not.
RuntimeTypes typeutil.Map
}
// Working state of the RTA algorithm.
type rta struct {
result *Result
prog *ir.Program
worklist []*ir.Function // list of functions to visit
// addrTakenFuncsBySig contains all address-taken *Functions, grouped by signature.
// Keys are *types.Signature, values are map[*ir.Function]bool sets.
addrTakenFuncsBySig typeutil.Map
// dynCallSites contains all dynamic "call"-mode call sites, grouped by signature.
// Keys are *types.Signature, values are unordered []ir.CallInstruction.
dynCallSites typeutil.Map
// invokeSites contains all "invoke"-mode call sites, grouped by interface.
// Keys are *types.Interface (never *types.Named),
// Values are unordered []ir.CallInstruction sets.
invokeSites typeutil.Map
// The following two maps together define the subset of the
// m:n "implements" relation needed by the algorithm.
// concreteTypes maps each concrete type to the set of interfaces that it implements.
// Keys are types.Type, values are unordered []*types.Interface.
// Only concrete types used as MakeInterface operands are included.
concreteTypes typeutil.Map
// interfaceTypes maps each interface type to
// the set of concrete types that implement it.
// Keys are *types.Interface, values are unordered []types.Type.
// Only interfaces used in "invoke"-mode CallInstructions are included.
interfaceTypes typeutil.Map
}
// addReachable marks a function as potentially callable at run-time,
// and ensures that it gets processed.
func (r *rta) addReachable(f *ir.Function, addrTaken bool) {
reachable := r.result.Reachable
n := len(reachable)
v := reachable[f]
if addrTaken {
v.AddrTaken = true
}
reachable[f] = v
if len(reachable) > n {
// First time seeing f. Add it to the worklist.
r.worklist = append(r.worklist, f)
}
}
// addEdge adds the specified call graph edge, and marks it reachable.
// addrTaken indicates whether to mark the callee as "address-taken".
func (r *rta) addEdge(site ir.CallInstruction, callee *ir.Function, addrTaken bool) {
r.addReachable(callee, addrTaken)
if g := r.result.CallGraph; g != nil {
if site.Parent() == nil {
panic(site)
}
from := g.CreateNode(site.Parent())
to := g.CreateNode(callee)
callgraph.AddEdge(from, site, to)
}
}
// ---------- addrTakenFuncs Γ dynCallSites ----------
// visitAddrTakenFunc is called each time we encounter an address-taken function f.
func (r *rta) visitAddrTakenFunc(f *ir.Function) {
// Create two-level map (Signature -> Function -> bool).
S := f.Signature
funcs, _ := r.addrTakenFuncsBySig.At(S).(map[*ir.Function]bool)
if funcs == nil {
funcs = make(map[*ir.Function]bool)
r.addrTakenFuncsBySig.Set(S, funcs)
}
if !funcs[f] {
// First time seeing f.
funcs[f] = true
// If we've seen any dyncalls of this type, mark it reachable,
// and add call graph edges.
sites, _ := r.dynCallSites.At(S).([]ir.CallInstruction)
for _, site := range sites {
r.addEdge(site, f, true)
}
}
}
// visitDynCall is called each time we encounter a dynamic "call"-mode call.
func (r *rta) visitDynCall(site ir.CallInstruction) {
S := site.Common().Signature()
// Record the call site.
sites, _ := r.dynCallSites.At(S).([]ir.CallInstruction)
r.dynCallSites.Set(S, append(sites, site))
// For each function of signature S that we know is address-taken,
// mark it reachable. We'll add the callgraph edges later.
funcs, _ := r.addrTakenFuncsBySig.At(S).(map[*ir.Function]bool)
for g := range funcs {
r.addEdge(site, g, true)
}
}
// ---------- concrete types Γ invoke sites ----------
// addInvokeEdge is called for each new pair (site, C) in the matrix.
func (r *rta) addInvokeEdge(site ir.CallInstruction, C types.Type) {
// Ascertain the concrete method of C to be called.
imethod := site.Common().Method
cmethod := r.prog.MethodValue(r.prog.MethodSets.MethodSet(C).Lookup(imethod.Pkg(), imethod.Name()))
r.addEdge(site, cmethod, true)
}
// visitInvoke is called each time the algorithm encounters an "invoke"-mode call.
func (r *rta) visitInvoke(site ir.CallInstruction) {
I := site.Common().Value.Type().Underlying().(*types.Interface)
// Record the invoke site.
sites, _ := r.invokeSites.At(I).([]ir.CallInstruction)
r.invokeSites.Set(I, append(sites, site))
// Add callgraph edge for each existing
// address-taken concrete type implementing I.
for _, C := range r.implementations(I) {
r.addInvokeEdge(site, C)
}
}
// ---------- main algorithm ----------
// visitFunc processes function f.
func (r *rta) visitFunc(f *ir.Function) {
var space [32]*ir.Value // preallocate space for common case
for _, b := range f.Blocks {
for _, instr := range b.Instrs {
rands := instr.Operands(space[:0])
switch instr := instr.(type) {
case ir.CallInstruction:
call := instr.Common()
if call.IsInvoke() {
r.visitInvoke(instr)
} else if g := call.StaticCallee(); g != nil {
r.addEdge(instr, g, false)
} else if _, ok := call.Value.(*ir.Builtin); !ok {
r.visitDynCall(instr)
}
// Ignore the call-position operand when
// looking for address-taken Functions.
// Hack: assume this is rands[0].
rands = rands[1:]
case *ir.MakeInterface:
r.addRuntimeType(instr.X.Type(), false)
}
// Process all address-taken functions.
for _, op := range rands {
if g, ok := (*op).(*ir.Function); ok {
r.visitAddrTakenFunc(g)
}
}
}
}
}
// Analyze performs Rapid Type Analysis, starting at the specified root
// functions. It returns nil if no roots were specified.
//
// If buildCallGraph is true, Result.CallGraph will contain a call
// graph; otherwise, only the other fields (reachable functions) are
// populated.
//
func Analyze(roots []*ir.Function, buildCallGraph bool) *Result {
if len(roots) == 0 {
return nil
}
r := &rta{
result: &Result{Reachable: make(map[*ir.Function]struct{ AddrTaken bool })},
prog: roots[0].Prog,
}
if buildCallGraph {
// TODO(adonovan): change callgraph API to eliminate the
// notion of a distinguished root node. Some callgraphs
// have many roots, or none.
r.result.CallGraph = callgraph.New(roots[0])
}
hasher := typeutil.MakeHasher()
r.result.RuntimeTypes.SetHasher(hasher)
r.addrTakenFuncsBySig.SetHasher(hasher)
r.dynCallSites.SetHasher(hasher)
r.invokeSites.SetHasher(hasher)
r.concreteTypes.SetHasher(hasher)
r.interfaceTypes.SetHasher(hasher)
// Visit functions, processing their instructions, and adding
// new functions to the worklist, until a fixed point is
// reached.
var shadow []*ir.Function // for efficiency, we double-buffer the worklist
r.worklist = append(r.worklist, roots...)
for len(r.worklist) > 0 {
shadow, r.worklist = r.worklist, shadow[:0]
for _, f := range shadow {
r.visitFunc(f)
}
}
return r.result
}
// interfaces(C) returns all currently known interfaces implemented by C.
func (r *rta) interfaces(C types.Type) []*types.Interface {
// Ascertain set of interfaces C implements
// and update 'implements' relation.
var ifaces []*types.Interface
r.interfaceTypes.Iterate(func(I types.Type, concs interface{}) {
if I := I.(*types.Interface); types.Implements(C, I) {
concs, _ := concs.([]types.Type)
r.interfaceTypes.Set(I, append(concs, C))
ifaces = append(ifaces, I)
}
})
r.concreteTypes.Set(C, ifaces)
return ifaces
}
// implementations(I) returns all currently known concrete types that implement I.
func (r *rta) implementations(I *types.Interface) []types.Type {
var concs []types.Type
if v := r.interfaceTypes.At(I); v != nil {
concs = v.([]types.Type)
} else {
// First time seeing this interface.
// Update the 'implements' relation.
r.concreteTypes.Iterate(func(C types.Type, ifaces interface{}) {
if types.Implements(C, I) {
ifaces, _ := ifaces.([]*types.Interface)
r.concreteTypes.Set(C, append(ifaces, I))
concs = append(concs, C)
}
})
r.interfaceTypes.Set(I, concs)
}
return concs
}
// addRuntimeType is called for each concrete type that can be the
// dynamic type of some interface or reflect.Value.
// Adapted from needMethods in go/ir/builder.go
//
func (r *rta) addRuntimeType(T types.Type, skip bool) {
if prev, ok := r.result.RuntimeTypes.At(T).(bool); ok {
if skip && !prev {
r.result.RuntimeTypes.Set(T, skip)
}
return
}
r.result.RuntimeTypes.Set(T, skip)
mset := r.prog.MethodSets.MethodSet(T)
if _, ok := T.Underlying().(*types.Interface); !ok {
// T is a new concrete type.
for i, n := 0, mset.Len(); i < n; i++ {
sel := mset.At(i)
m := sel.Obj()
if m.Exported() {
// Exported methods are always potentially callable via reflection.
r.addReachable(r.prog.MethodValue(sel), true)
}
}
// Add callgraph edge for each existing dynamic
// "invoke"-mode call via that interface.
for _, I := range r.interfaces(T) {
sites, _ := r.invokeSites.At(I).([]ir.CallInstruction)
for _, site := range sites {
r.addInvokeEdge(site, T)
}
}
}
// Precondition: T is not a method signature (*Signature with Recv()!=nil).
// Recursive case: skip => don't call makeMethods(T).
// Each package maintains its own set of types it has visited.
var n *types.Named
switch T := T.(type) {
case *types.Named:
n = T
case *types.Pointer:
n, _ = T.Elem().(*types.Named)
}
if n != nil {
owner := n.Obj().Pkg()
if owner == nil {
return // built-in error type
}
}
// Recursion over signatures of each exported method.
for i := 0; i < mset.Len(); i++ {
if mset.At(i).Obj().Exported() {
sig := mset.At(i).Type().(*types.Signature)
r.addRuntimeType(sig.Params(), true) // skip the Tuple itself
r.addRuntimeType(sig.Results(), true) // skip the Tuple itself
}
}
switch t := T.(type) {
case *types.Basic:
// nop
case *types.Interface:
// nop---handled by recursion over method set.
case *types.Pointer:
r.addRuntimeType(t.Elem(), false)
case *types.Slice:
r.addRuntimeType(t.Elem(), false)
case *types.Chan:
r.addRuntimeType(t.Elem(), false)
case *types.Map:
r.addRuntimeType(t.Key(), false)
r.addRuntimeType(t.Elem(), false)
case *types.Signature:
if t.Recv() != nil {
panic(fmt.Sprintf("Signature %s has Recv %s", t, t.Recv()))
}
r.addRuntimeType(t.Params(), true) // skip the Tuple itself
r.addRuntimeType(t.Results(), true) // skip the Tuple itself
case *types.Named:
// A pointer-to-named type can be derived from a named
// type via reflection. It may have methods too.
r.addRuntimeType(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.
r.addRuntimeType(t.Underlying(), true)
case *types.Array:
r.addRuntimeType(t.Elem(), false)
case *types.Struct:
for i, n := 0, t.NumFields(); i < n; i++ {
r.addRuntimeType(t.Field(i).Type(), false)
}
case *types.Tuple:
for i, n := 0, t.Len(); i < n; i++ {
r.addRuntimeType(t.At(i).Type(), false)
}
default:
panic(T)
}
}
go-tools-2021.1.2/go/callgraph/rta/rta_test.go 0000664 0000000 0000000 00000006371 14143223131 0021007 0 ustar 00root root 0000000 0000000 // Copyright 2014 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/callgraph's test suite is built around the deprecated go/loader. We'll leave fixing that to upstream.
// No testdata on Android.
// +build !android
package rta_test
import (
"bytes"
"fmt"
"go/ast"
"go/parser"
"go/token"
"go/types"
"io/ioutil"
"sort"
"strings"
"testing"
"honnef.co/go/tools/go/callgraph"
"honnef.co/go/tools/go/callgraph/rta"
"honnef.co/go/tools/go/ir"
"honnef.co/go/tools/go/ir/irutil"
"golang.org/x/tools/go/loader"
)
var inputs = []string{
"testdata/func.go",
"testdata/rtype.go",
"testdata/iface.go",
}
func expectation(f *ast.File) (string, token.Pos) {
for _, c := range f.Comments {
text := strings.TrimSpace(c.Text())
if t := strings.TrimPrefix(text, "WANT:\n"); t != text {
return t, c.Pos()
}
}
return "", token.NoPos
}
// TestRTA runs RTA on each file in inputs, prints the results, and
// compares it with the golden results embedded in the WANT comment at
// the end of the file.
//
// The results string consists of two parts: the set of dynamic call
// edges, "f --> g", one per line, and the set of reachable functions,
// one per line. Each set is sorted.
//
func TestRTA(t *testing.T) {
for _, filename := range inputs {
content, err := ioutil.ReadFile(filename)
if err != nil {
t.Errorf("couldn't read file '%s': %s", filename, err)
continue
}
conf := loader.Config{
ParserMode: parser.ParseComments,
}
f, err := conf.ParseFile(filename, content)
if err != nil {
t.Error(err)
continue
}
want, pos := expectation(f)
if pos == token.NoPos {
t.Errorf("No WANT: comment in %s", filename)
continue
}
conf.CreateFromFiles("main", f)
iprog, err := conf.Load()
if err != nil {
t.Error(err)
continue
}
prog := irutil.CreateProgram(iprog, 0)
mainPkg := prog.Package(iprog.Created[0].Pkg)
prog.Build()
res := rta.Analyze([]*ir.Function{
mainPkg.Func("main"),
mainPkg.Func("init"),
}, true)
if got := printResult(res, mainPkg.Pkg); got != want {
t.Errorf("%s: got:\n%s\nwant:\n%s",
prog.Fset.Position(pos), got, want)
}
}
}
func printResult(res *rta.Result, from *types.Package) string {
var buf bytes.Buffer
writeSorted := func(ss []string) {
sort.Strings(ss)
for _, s := range ss {
fmt.Fprintf(&buf, " %s\n", s)
}
}
buf.WriteString("Dynamic calls\n")
var edges []string
callgraph.GraphVisitEdges(res.CallGraph, func(e *callgraph.Edge) error {
if strings.Contains(e.Description(), "dynamic") {
edges = append(edges, fmt.Sprintf("%s --> %s",
e.Caller.Func.RelString(from),
e.Callee.Func.RelString(from)))
}
return nil
})
writeSorted(edges)
buf.WriteString("Reachable functions\n")
var reachable []string
for f := range res.Reachable {
reachable = append(reachable, f.RelString(from))
}
writeSorted(reachable)
buf.WriteString("Reflect types\n")
var rtypes []string
res.RuntimeTypes.Iterate(func(key types.Type, value interface{}) {
if value == false { // accessible to reflection
rtypes = append(rtypes, types.TypeString(key, types.RelativeTo(from)))
}
})
writeSorted(rtypes)
return strings.TrimSpace(buf.String())
}
go-tools-2021.1.2/go/callgraph/rta/testdata/ 0000775 0000000 0000000 00000000000 14143223131 0020435 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/go/callgraph/rta/testdata/func.go 0000664 0000000 0000000 00000000762 14143223131 0021724 0 ustar 00root root 0000000 0000000 //+build ignore
package main
// Test of dynamic function calls.
// No interfaces, so no runtime/reflect types.
func A1() {
A2(0)
}
func A2(int) {} // not address-taken
func B() {} // unreachable
var (
C = func(int) {}
D = func(int) {}
)
func main() {
A1()
pfn := C
pfn(0) // calls C and D but not A2 (same sig but not address-taken)
}
// WANT:
// Dynamic calls
// main --> init$1
// main --> init$2
// Reachable functions
// A1
// A2
// init$1
// init$2
// Reflect types
go-tools-2021.1.2/go/callgraph/rta/testdata/iface.go 0000664 0000000 0000000 00000002375 14143223131 0022042 0 ustar 00root root 0000000 0000000 //+build ignore
package main
// Test of interface calls.
func use(interface{})
type A byte // instantiated but not a reflect type
func (A) f() {} // called directly
func (A) F() {} // unreachable
type B int // a reflect type
func (*B) f() {} // reachable via interface invoke
func (*B) F() {} // reachable: exported method of reflect type
type B2 int // a reflect type, and *B2 also
func (B2) f() {} // reachable via interface invoke
func (B2) g() {} // reachable: exported method of reflect type
type C string // not instantiated
func (C) f() {} // unreachable
func (C) F() {} // unreachable
type D uint // instantiated only in dead code
func (D) f() {} // unreachable
func (D) F() {} // unreachable
func main() {
A(0).f()
use(new(B))
use(B2(0))
var i interface {
f()
}
i.f() // calls (*B).f, (*B2).f and (B2.f)
live()
}
func live() {
var j interface {
f()
g()
}
j.f() // calls (B2).f and (*B2).f but not (*B).f (no g method).
}
func dead() {
use(D(0))
}
// WANT:
// Dynamic calls
// live --> (*B2).f
// live --> (B2).f
// main --> (*B).f
// main --> (*B2).f
// main --> (B2).f
// Reachable functions
// (*B).F
// (*B).f
// (*B2).f
// (A).f
// (B2).f
// live
// use
// Reflect types
// *B
// *B2
// B
// B2
go-tools-2021.1.2/go/callgraph/rta/testdata/rtype.go 0000664 0000000 0000000 00000001147 14143223131 0022132 0 ustar 00root root 0000000 0000000 //+build ignore
package main
// Test of runtime types (types for which descriptors are needed).
func use(interface{})
type A byte // neither A nor byte are runtime types
type B struct{ x uint } // B and uint are runtime types, but not the struct
func main() {
var x int // not a runtime type
print(x)
var y string // runtime type due to interface conversion
use(y)
use(struct{ uint64 }{}) // struct is a runtime type
use(new(B)) // *B is a runtime type
}
// WANT:
// Dynamic calls
// Reachable functions
// use
// Reflect types
// *B
// B
// string
// struct{uint64}
// uint
// uint64
go-tools-2021.1.2/go/callgraph/static/ 0000775 0000000 0000000 00000000000 14143223131 0017325 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/go/callgraph/static/static.go 0000664 0000000 0000000 00000001763 14143223131 0021152 0 ustar 00root root 0000000 0000000 // Package static computes the call graph of a Go program containing
// only static call edges.
package static
import (
"honnef.co/go/tools/go/callgraph"
"honnef.co/go/tools/go/ir"
"honnef.co/go/tools/go/ir/irutil"
)
// CallGraph computes the call graph of the specified program
// considering only static calls.
//
func CallGraph(prog *ir.Program) *callgraph.Graph {
cg := callgraph.New(nil) // TODO(adonovan) eliminate concept of rooted callgraph
// TODO(adonovan): opt: use only a single pass over the ir.Program.
// TODO(adonovan): opt: this is slower than RTA (perhaps because
// the lower precision means so many edges are allocated)!
for f := range irutil.AllFunctions(prog) {
fnode := cg.CreateNode(f)
for _, b := range f.Blocks {
for _, instr := range b.Instrs {
if site, ok := instr.(ir.CallInstruction); ok {
if g := site.Common().StaticCallee(); g != nil {
gnode := cg.CreateNode(g)
callgraph.AddEdge(fnode, site, gnode)
}
}
}
}
}
return cg
}
go-tools-2021.1.2/go/callgraph/static/static_test.go 0000664 0000000 0000000 00000003047 14143223131 0022206 0 ustar 00root root 0000000 0000000 // Copyright 2014 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/callgraph's test suite is built around the deprecated go/loader. We'll leave fixing that to upstream.
package static_test
import (
"fmt"
"go/parser"
"reflect"
"sort"
"testing"
"honnef.co/go/tools/go/callgraph"
"honnef.co/go/tools/go/callgraph/static"
"honnef.co/go/tools/go/ir/irutil"
"golang.org/x/tools/go/loader"
)
const input = `package P
type C int
func (C) f()
type I interface{f()}
func f() {
p := func() {}
g()
p() // IR constant propagation => static
if unknown {
p = h
}
p() // dynamic
C(0).f()
}
func g() {
var i I = C(0)
i.f()
}
func h()
var unknown bool
`
func TestStatic(t *testing.T) {
conf := loader.Config{ParserMode: parser.ParseComments}
f, err := conf.ParseFile("P.go", input)
if err != nil {
t.Fatal(err)
}
conf.CreateFromFiles("P", f)
iprog, err := conf.Load()
if err != nil {
t.Fatal(err)
}
P := iprog.Created[0].Pkg
prog := irutil.CreateProgram(iprog, 0)
prog.Build()
cg := static.CallGraph(prog)
var edges []string
callgraph.GraphVisitEdges(cg, func(e *callgraph.Edge) error {
edges = append(edges, fmt.Sprintf("%s -> %s",
e.Caller.Func.RelString(P),
e.Callee.Func.RelString(P)))
return nil
})
sort.Strings(edges)
want := []string{
"(*C).f -> (C).f",
"f -> (C).f",
"f -> f$1",
"f -> g",
}
if !reflect.DeepEqual(edges, want) {
t.Errorf("Got edges %v, want %v", edges, want)
}
}
go-tools-2021.1.2/go/callgraph/util.go 0000664 0000000 0000000 00000011156 14143223131 0017346 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 callgraph
import "honnef.co/go/tools/go/ir"
// This file provides various utilities over call graphs, such as
// visitation and path search.
// CalleesOf returns a new set containing all direct callees of the
// caller node.
//
func CalleesOf(caller *Node) map[*Node]bool {
callees := make(map[*Node]bool)
for _, e := range caller.Out {
callees[e.Callee] = true
}
return callees
}
// GraphVisitEdges visits all the edges in graph g in depth-first order.
// The edge function is called for each edge in postorder. If it
// returns non-nil, visitation stops and GraphVisitEdges returns that
// value.
//
func GraphVisitEdges(g *Graph, edge func(*Edge) error) error {
seen := make(map[*Node]bool)
var visit func(n *Node) error
visit = func(n *Node) error {
if !seen[n] {
seen[n] = true
for _, e := range n.Out {
if err := visit(e.Callee); err != nil {
return err
}
if err := edge(e); err != nil {
return err
}
}
}
return nil
}
for _, n := range g.Nodes {
if err := visit(n); err != nil {
return err
}
}
return nil
}
// PathSearch finds an arbitrary path starting at node start and
// ending at some node for which isEnd() returns true. On success,
// PathSearch returns the path as an ordered list of edges; on
// failure, it returns nil.
//
func PathSearch(start *Node, isEnd func(*Node) bool) []*Edge {
stack := make([]*Edge, 0, 32)
seen := make(map[*Node]bool)
var search func(n *Node) []*Edge
search = func(n *Node) []*Edge {
if !seen[n] {
seen[n] = true
if isEnd(n) {
return stack
}
for _, e := range n.Out {
stack = append(stack, e) // push
if found := search(e.Callee); found != nil {
return found
}
stack = stack[:len(stack)-1] // pop
}
}
return nil
}
return search(start)
}
// DeleteSyntheticNodes removes from call graph g all nodes for
// synthetic functions (except g.Root and package initializers),
// preserving the topology. In effect, calls to synthetic wrappers
// are "inlined".
//
func (g *Graph) DeleteSyntheticNodes() {
// Measurements on the standard library and go.tools show that
// resulting graph has ~15% fewer nodes and 4-8% fewer edges
// than the input.
//
// Inlining a wrapper of in-degree m, out-degree n adds m*n
// and removes m+n edges. Since most wrappers are monomorphic
// (n=1) this results in a slight reduction. Polymorphic
// wrappers (n>1), e.g. from embedding an interface value
// inside a struct to satisfy some interface, cause an
// increase in the graph, but they seem to be uncommon.
// Hash all existing edges to avoid creating duplicates.
edges := make(map[Edge]bool)
for _, cgn := range g.Nodes {
for _, e := range cgn.Out {
edges[*e] = true
}
}
for fn, cgn := range g.Nodes {
if cgn == g.Root || fn.Synthetic == 0 || isInit(cgn.Func) {
continue // keep
}
for _, eIn := range cgn.In {
for _, eOut := range cgn.Out {
newEdge := Edge{eIn.Caller, eIn.Site, eOut.Callee}
if edges[newEdge] {
continue // don't add duplicate
}
AddEdge(eIn.Caller, eIn.Site, eOut.Callee)
edges[newEdge] = true
}
}
g.DeleteNode(cgn)
}
}
func isInit(fn *ir.Function) bool {
return fn.Pkg != nil && fn.Pkg.Func("init") == fn
}
// DeleteNode removes node n and its edges from the graph g.
// (NB: not efficient for batch deletion.)
func (g *Graph) DeleteNode(n *Node) {
n.deleteIns()
n.deleteOuts()
delete(g.Nodes, n.Func)
}
// deleteIns deletes all incoming edges to n.
func (n *Node) deleteIns() {
for _, e := range n.In {
removeOutEdge(e)
}
n.In = nil
}
// deleteOuts deletes all outgoing edges from n.
func (n *Node) deleteOuts() {
for _, e := range n.Out {
removeInEdge(e)
}
n.Out = nil
}
// removeOutEdge removes edge.Caller's outgoing edge 'edge'.
func removeOutEdge(edge *Edge) {
caller := edge.Caller
n := len(caller.Out)
for i, e := range caller.Out {
if e == edge {
// Replace it with the final element and shrink the slice.
caller.Out[i] = caller.Out[n-1]
caller.Out[n-1] = nil // aid GC
caller.Out = caller.Out[:n-1]
return
}
}
panic("edge not found: " + edge.String())
}
// removeInEdge removes edge.Callee's incoming edge 'edge'.
func removeInEdge(edge *Edge) {
caller := edge.Callee
n := len(caller.In)
for i, e := range caller.In {
if e == edge {
// Replace it with the final element and shrink the slice.
caller.In[i] = caller.In[n-1]
caller.In[n-1] = nil // aid GC
caller.In = caller.In[:n-1]
return
}
}
panic("edge not found: " + edge.String())
}
go-tools-2021.1.2/go/gcsizes/ 0000775 0000000 0000000 00000000000 14143223131 0015550 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/go/gcsizes/LICENSE 0000664 0000000 0000000 00000002707 14143223131 0016563 0 ustar 00root root 0000000 0000000 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.
go-tools-2021.1.2/go/gcsizes/sizes.go 0000664 0000000 0000000 00000005330 14143223131 0017235 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 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
}
go-tools-2021.1.2/go/ir/ 0000775 0000000 0000000 00000000000 14143223131 0014513 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/go/ir/LICENSE 0000664 0000000 0000000 00000002777 14143223131 0015535 0 ustar 00root root 0000000 0000000 Copyright (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.
go-tools-2021.1.2/go/ir/UPSTREAM 0000664 0000000 0000000 00000000713 14143223131 0015677 0 ustar 00root root 0000000 0000000 This 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:
915f6209478fe61eb90dbe155a8a1c58655b931f
go-tools-2021.1.2/go/ir/bench_test.go 0000664 0000000 0000000 00000001472 14143223131 0017164 0 ustar 00root root 0000000 0000000 package 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()
}
}
go-tools-2021.1.2/go/ir/blockopt.go 0000664 0000000 0000000 00000012043 14143223131 0016657 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
// 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()
}
go-tools-2021.1.2/go/ir/builder.go 0000664 0000000 0000000 00000204511 14143223131 0016473 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 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"
"os"
)
type opaqueType struct {
types.Type
name string
}
func (t *opaqueType) String() string { return t.name }
var (
varOk = newVar("ok", tBool)
varIndex = newVar("index", tInt)
// Type constants.
tBool = types.Typ[types.Bool]
tByte = types.Typ[types.Byte]
tInt = types.Typ[types.Int]
tInvalid = types.Typ[types.Invalid]
tString = types.Typ[types.String]
tUntypedNil = types.Typ[types.UntypedNil]
tRangeIter = &opaqueType{nil, "iter"} // the type of all "range" iterators
tEface = types.NewInterfaceType(nil, nil).Complete()
)
// 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))
case token.LOR:
b.cond(fn, e.X, done, rhs)
short = emitConst(fn, NewConst(constant.MakeBool(true), t))
}
// 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
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 := 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":
switch typ.Underlying().(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(typ.Underlying().(*types.Slice).Elem(), cap)
alloc := emitNew(fn, at, source)
v := &Slice{
X: alloc,
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))
if len(args) == 2 {
sz = b.expr(fn, args[1])
}
v := &MakeChan{Size: sz}
v.setType(typ)
return fn.emit(v, source)
}
case "new":
alloc := emitNew(fn, deref(typ), source)
return alloc
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.)
t := deref(fn.Pkg.typeOf(args[0])).Underlying()
if at, ok := t.(*types.Array); ok {
b.expr(fn, args[0]) // for effects only
return emitConst(fn, intConst(at.Len()))
}
// 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)) // 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) 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, 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)
} else {
v = fn.addLocal(t, e)
}
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)
last := len(sel.Index()) - 1
return &address{
addr: emitFieldSelection(fn, v, sel.Index()[last], true, e.Sel),
expr: e.Sel,
}
case *ast.IndexExpr:
var x Value
var et types.Type
switch t := fn.Pkg.typeOf(e.X).Underlying().(type) {
case *types.Array:
x = b.addr(fn, e.X, escaping).address(fn)
et = types.NewPointer(t.Elem())
case *types.Pointer: // *array
x = b.expr(fn, e.X)
et = types.NewPointer(t.Elem().Underlying().(*types.Array).Elem())
case *types.Slice:
x = b.expr(fn, e.X)
et = types.NewPointer(t.Elem())
case *types.Map:
return &element{
m: b.expr(fn, e.X),
k: emitConv(fn, b.expr(fn, e.Index), t.Key(), e.Index),
t: t.Elem(),
}
default:
panic("unexpected container type in IndexExpr: " + t.String())
}
v := &IndexAddr{
X: x,
Index: emitConv(fn, b.expr(fn, e.Index), tInt, e.Index),
}
v.setType(et)
return &address{addr: fn.emit(v, e), 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
}
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})
}
func (sb *storebuf) emit(fn *Function) {
for _, s := range sb.stores {
s.lhs.store(fn, s.rhs, s.source)
}
}
// 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()) {
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 isInterface(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 loc.typ().Underlying().(type) {
case *types.Struct, *types.Array:
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))
}
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),
}
fn2.source = e
fn.AnonFuncs = append(fn.AnonFuncs, fn2)
fn2.initHTML(b.printFunc)
b.buildFunction(fn2)
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 (http://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 low, high, max Value
var x Value
switch fn.Pkg.typeOf(e.X).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")
}
if e.High != nil {
high = b.expr(fn, e.High)
}
if e.Low != nil {
low = b.expr(fn, e.Low)
}
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))
}
// 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)
}
return v // (func)
}
// Local var.
return emitLoad(fn, fn.lookup(obj, 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 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:
switch t := fn.Pkg.typeOf(e.X).Underlying().(type) {
case *types.Array:
// Non-addressable array (in a register).
v := &Index{
X: b.expr(fn, e.X),
Index: emitConv(fn, b.expr(fn, e.Index), tInt, e.Index),
}
v.setType(t.Elem())
return fn.emit(v, e)
case *types.Map:
// Maps are not addressable.
mapt := fn.Pkg.typeOf(e.X).Underlying().(*types.Map)
v := &MapLookup{
X: b.expr(fn, e.X),
Index: emitConv(fn, b.expr(fn, e.Index), mapt.Key(), e.Index),
}
v.setType(mapt.Elem())
return fn.emit(v, e)
case *types.Basic: // => string
// Strings are not addressable.
v := &StringLookup{
X: b.expr(fn, e.X),
Index: b.expr(fn, e.Index),
}
v.setType(tByte)
return fn.emit(v, e)
case *types.Slice, *types.Pointer: // *array
// Addressable slice/array; use IndexAddr and Load.
return b.addr(fn, e, false).load(fn, e)
default:
panic("unexpected container type in IndexExpr: " + t.String())
}
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 isInterface(recv) {
// Invoke-mode call.
c.Value = v
c.Method = obj
} else {
// "Call"-mode call.
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.
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)))
} else {
// Replace a suffix of args with a slice containing it.
at := types.NewArray(vt, int64(len(varargs)))
a := emitNew(fn, at, e)
a.source = e
for i, arg := range varargs {
iaddr := &IndexAddr{
X: a,
Index: emitConst(fn, intConst(int64(i))),
}
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, _ := fn.Pkg.typeOf(e.Fun).Underlying().(*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) {
oldv := loc.load(fn, source)
loc.store(fn, emitArith(fn, op, oldv, emitConv(fn, val, oldv.Type(), source), 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) {
fn.addLocalForIdent(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 := fn.addLocalForIdent(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) {
fn.addLocalForIdent(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 := fn.Pkg.info.Defs[lhs.(*ast.Ident)]; obj != nil {
fn.addNamedLocal(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. Thus all stores to
// loc are emitted to the storebuf sb for later execution.
//
// 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 := typ.Underlying().(type) {
case *types.Struct:
if !isZero && len(e.Elts) != t.NumFields() {
// memclear
sb.store(&address{addr, nil}, zeroValue(fn, deref(addr.Type()), e), e)
isZero = true
}
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
}
}
}
sf := t.Field(fieldIndex)
faddr := &FieldAddr{
X: addr,
Field: fieldIndex,
}
faddr.setType(types.NewPointer(sf.Type()))
fn.emit(faddr, e)
b.assign(fn, &address{addr: faddr, expr: e}, e, isZero, sb, 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))
alloc := emitNew(fn, at, e)
array = alloc
case *types.Array:
at = t
array = addr
if !isZero && int64(len(e.Elts)) != at.Len() {
// 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))
}
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
s := &Slice{X: array}
s.setType(typ)
sb.store(&address{addr: addr, expr: e}, fn.emit(s, e), e)
}
case *types.Map:
m := &MakeMap{Reserve: emitConst(fn, intConst(int64(len(e.Elts))))}
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))
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 := fn.addLocal(tagv.Type(), tagSource)
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 := fn.addLocal(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 := fn.Pkg.info.Implicits[cc]; obj != nil {
fn.addNamedLocal(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))))
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))))
// 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 := fn.Pkg.info.Implicits[cc]; obj != nil {
// 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.objects[obj]
if rets[index] == tUntypedNil {
emitStore(fn, l, emitConst(fn, nilConst(tswtch.Tag.Type())), 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 := fn.Pkg.info.Implicits[default_]; obj != nil {
l := fn.objects[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),
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 := 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)))
continue
}
swtch.Conds = append(swtch.Conds, emitConst(fn, intConst(int64(state))))
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 {
fn.addLocalForIdent(comm.Lhs[0].(*ast.Ident))
}
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 {
fn.addLocalForIdent(comm.Lhs[1].(*ast.Ident))
}
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) {
// ...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
}
// 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)
// Determine number of iterations.
var length Value
if arr, ok := deref(x.Type()).Underlying().(*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.
length = emitConst(fn, intConst(arr.Len()))
} else {
// length = len(x).
var c Call
c.Call.Value = makeLen(x.Type())
c.Call.Args = []Value{x}
c.setType(tInt)
length = fn.emit(&c, source)
}
index := fn.addLocal(tInt, source)
emitStore(fn, index, emitConst(fn, intConst(-1)), 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)),
}
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, source), body, done, source)
fn.currentBlock = body
k = emitLoad(fn, index, source)
if tv != nil {
switch t := 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(tRangeIter)
it := fn.emit(rng, source)
loop = fn.newBasicBlock("rangeiter.loop")
emitJump(fn, loop, source)
fn.currentBlock = loop
_, isString := x.Type().Underlying().(*types.Basic)
okv := &Next{
Iter: it,
IsString: isString,
}
okv.setType(types.NewTuple(
varOk,
newVar("k", tk),
newVar("v", tv),
))
fn.emit(okv, source)
body := fn.newBasicBlock("rangeiter.body")
done = fn.newBasicBlock("rangeiter.done")
emitIf(fn, emitExtract(fn, okv, 0, source), body, done, source)
fn.currentBlock = body
if tk != tInvalid {
k = emitExtract(fn, okv, 1, source)
}
if tv != tInvalid {
v = emitExtract(fn, okv, 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
retv := emitRecv(fn, x, true, types.NewTuple(newVar("k", x.Type().Underlying().(*types.Chan).Elem()), varOk), source)
body := fn.newBasicBlock("rangechan.body")
done = fn.newBasicBlock("rangechan.done")
emitIf(fn, emitExtract(fn, retv, 1, source), body, done, source)
fn.currentBlock = body
if tk != nil {
k = emitExtract(fn, retv, 0, source)
}
return
}
// 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)
}
// If iteration variables are defined (:=), this
// occurs once outside the loop.
//
// Unlike a short variable declaration, a RangeStmt
// using := never redeclares an existing variable; it
// always creates a new one.
if s.Tok == token.DEFINE {
if tk != nil {
fn.addLocalForIdent(s.Key.(*ast.Ident))
}
if tv != nil {
fn.addLocalForIdent(s.Value.(*ast.Ident))
}
}
x := b.expr(fn, s.X)
var k, v Value
var loop, done *BasicBlock
switch rt := 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, *types.Basic: // string
k, v, loop, done = b.rangeIter(fn, x, tk, tv, source)
default:
panic("Cannot range over: " + rt.String())
}
// 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
}
// 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:
label = fn.labelledBlock(s.Label)
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),
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())), 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.
v := Defer{}
b.setCall(fn, s.Call, &v.Call)
fn.hasDefer = true
fn.emit(&v, s)
case *ast.ReturnStmt:
// TODO(dh): we could emit tighter position information by
// using the ith returned expression
var results []Value
if len(s.Results) == 1 && fn.Signature.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),
fn.Signature.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), fn.Signature.Results().At(i).Type(), s)
results = append(results, v)
}
}
ret := fn.results()
for i, r := range results {
emitStore(fn, ret[i], r, s)
}
emitJump(fn, fn.Exit, s)
fn.currentBlock = fn.newBasicBlock("unreachable")
case *ast.BranchStmt:
var block *BasicBlock
switch s.Tok {
case token.BREAK:
if s.Label != nil {
block = fn.labelledBlock(s.Label)._break
} else {
for t := fn.targets; t != nil && block == nil; t = t.tail {
block = t._break
}
}
case token.CONTINUE:
if s.Label != nil {
block = fn.labelledBlock(s.Label)._continue
} else {
for t := fn.targets; t != nil && block == nil; t = t.tail {
block = t._continue
}
}
case token.FALLTHROUGH:
for t := fn.targets; t != nil && block == nil; t = t.tail {
block = t._fallthrough
}
case token.GOTO:
block = fn.labelledBlock(s.Label)._goto
}
j := emitJump(fn, block, s)
j.Comment = s.Tok.String()
fn.currentBlock = fn.newBasicBlock("unreachable")
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))
}
}
// 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.addParamObj(recv, nil)
}
params := fn.Signature.Params()
for i, n := 0, params.Len(); i < n; i++ {
// XXX synthesize an ast.Node
fn.addParamObj(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.startBody()
fn.createSyntacticParams(recvField, functype)
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
}
// 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
if isBlankIdent(id) {
return // discard
}
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)
// 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()))
}
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)
}
}
}
// 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()
p.info = nil // We no longer need ASTs or go/types deductions.
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())))
}
go-tools-2021.1.2/go/ir/builder_go117_test.go 0000664 0000000 0000000 00000002416 14143223131 0020450 0 ustar 00root root 0000000 0000000 // Copyright 2021 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.
//go:build go1.17
// +build go1.17
package ir_test
import (
"go/ast"
"go/importer"
"go/parser"
"go/token"
"go/types"
"testing"
"honnef.co/go/tools/go/ir"
"honnef.co/go/tools/go/ir/irutil"
)
func TestBuildPackageGo117(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)
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)
}
})
}
}
go-tools-2021.1.2/go/ir/builder_test.go 0000664 0000000 0000000 00000031041 14143223131 0017526 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
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, 0)
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(" {"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]interface{}>
// t4 = IndexAddr <*interface{}> t3 t2
// t5 = MakeInterface t1
// Store {interface{}} t4 t5
// t7 = Slice <[]interface{}> 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.LoadSyntax}
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.LoadAllSyntax}
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()
}
go-tools-2021.1.2/go/ir/exits.go 0000664 0000000 0000000 00000023542 14143223131 0016204 0 ustar 00root root 0000000 0000000 package 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
}
}
}
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.NewSignature(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
}
}
}
}
}
go-tools-2021.1.2/go/ir/func.go 0000664 0000000 0000000 00000060615 14143223131 0016005 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 Function and BasicBlock types.
import (
"bytes"
"fmt"
"go/ast"
"go/constant"
"go/format"
"go/token"
"go/types"
"io"
"os"
"strings"
)
// 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.
//
type lblock struct {
_goto *BasicBlock
_break *BasicBlock
_continue *BasicBlock
}
// labelledBlock returns the branch target associated with the
// specified label, creating it if needed.
//
func (f *Function) labelledBlock(label *ast.Ident) *lblock {
lb := f.lblocks[label.Obj]
if lb == nil {
lb = &lblock{_goto: f.newBasicBlock(label.Name)}
if f.lblocks == nil {
f.lblocks = make(map[*ast.Object]*lblock)
}
f.lblocks[label.Obj] = lb
}
return lb
}
// addParam adds a (non-escaping) parameter to f.Params of the
// specified name, type and source position.
//
func (f *Function) addParam(name string, typ types.Type, source ast.Node) *Parameter {
var b *BasicBlock
if len(f.Blocks) > 0 {
b = f.Blocks[0]
}
v := &Parameter{
name: name,
}
v.setBlock(b)
v.setType(typ)
v.setSource(source)
f.Params = append(f.Params, v)
if b != nil {
// There may be no blocks if this function has no body. We
// still create params, but aren't interested in the
// instruction.
f.Blocks[0].Instrs = append(f.Blocks[0].Instrs, v)
}
return v
}
func (f *Function) addParamObj(obj types.Object, source ast.Node) *Parameter {
name := obj.Name()
if name == "" {
name = fmt.Sprintf("arg%d", len(f.Params))
}
param := f.addParam(name, obj.Type(), source)
param.object = obj
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.Object, source ast.Node) {
param := f.addParamObj(obj, source)
spill := &Alloc{}
spill.setType(types.NewPointer(obj.Type()))
spill.source = source
f.objects[obj] = spill
f.Locals = append(f.Locals, spill)
f.emit(spill, 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.objects = make(map[types.Object]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
ret := f.results()
results := make([]Value, len(ret))
// Run function calls deferred in this
// function when explicitly returning from it.
f.emit(new(RunDefers), nil)
for i, r := range ret {
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(f.Pkg.info.Defs[n], n)
}
// Anonymous receiver? No need to spill.
if field.Names == nil {
f.addParamObj(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(f.Pkg.info.Defs[n], n)
}
// Anonymous parameter? No need to spill.
if field.Names == nil {
f.addParamObj(f.Signature.Params().At(len(f.Params)-n), field)
}
}
}
// Named results.
if functype.Results != nil {
for _, field := range functype.Results.List {
// Implicit "var" decl of locals for named results.
for _, n := range field.Names {
f.namedResults = append(f.namedResults, f.addLocalForIdent(n))
}
}
if len(f.namedResults) == 0 {
sig := f.Signature.Results()
for i := 0; i < sig.Len(); i++ {
// XXX position information
v := f.addLocal(sig.At(i).Type(), nil)
f.implicitResults = append(f.implicitResults, v)
}
}
}
}
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)
}
}
}
// 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
for _, rand := range rands {
if r := *rand; r != nil {
if ref := r.Referrers(); ref != nil {
if len(*ref) == 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
*ref = make([]Instruction, 1, 2)
(*ref)[0] = instr
} else {
*ref = append(*ref, instr)
}
}
}
}
}
}
}
func (f *Function) emitConsts() {
if len(f.Blocks) == 0 {
f.consts = nil
return
}
// TODO(dh): our deduplication only works on booleans and
// integers. other constants are represented as pointers to
// things.
if len(f.consts) == 0 {
return
} else if len(f.consts) <= 32 {
f.emitConstsFew()
} else {
f.emitConstsMany()
}
}
func (f *Function) emitConstsFew() {
dedup := make([]*Const, 0, 32)
for _, c := range f.consts {
if len(*c.Referrers()) == 0 {
continue
}
found := false
for _, d := range dedup {
if c.typ == d.typ && c.Value == d.Value {
replaceAll(c, d)
found = true
break
}
}
if !found {
dedup = append(dedup, c)
}
}
instrs := make([]Instruction, len(f.Blocks[0].Instrs)+len(dedup))
for i, c := range dedup {
instrs[i] = c
c.setBlock(f.Blocks[0])
}
copy(instrs[len(dedup):], f.Blocks[0].Instrs)
f.Blocks[0].Instrs = instrs
f.consts = nil
}
func (f *Function) emitConstsMany() {
type constKey struct {
typ types.Type
value constant.Value
}
m := make(map[constKey]Value, len(f.consts))
areNil := 0
for i, c := range f.consts {
if len(*c.Referrers()) == 0 {
f.consts[i] = nil
areNil++
continue
}
k := constKey{
typ: c.typ,
value: c.Value,
}
if dup, ok := m[k]; !ok {
m[k] = c
} else {
f.consts[i] = nil
areNil++
replaceAll(c, dup)
}
}
instrs := make([]Instruction, len(f.Blocks[0].Instrs)+len(f.consts)-areNil)
i := 0
for _, c := range f.consts {
if c != nil {
instrs[i] = c
c.setBlock(f.Blocks[0])
i++
}
}
copy(instrs[i:], f.Blocks[0].Instrs)
f.Blocks[0].Instrs = instrs
f.consts = nil
}
// 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.objects = nil
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 {
lift(f)
}
// emit constants after lifting, because lifting may produce new constants.
f.emitConsts()
f.namedResults = nil // (used by lifting)
f.implicitResults = nil
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
}
// addNamedLocal creates a local variable, adds it to function f and
// returns it. Its name and type are taken from obj. Subsequent
// calls to f.lookup(obj) will return the same local.
//
func (f *Function) addNamedLocal(obj types.Object, source ast.Node) *Alloc {
l := f.addLocal(obj.Type(), source)
f.objects[obj] = l
return l
}
func (f *Function) addLocalForIdent(id *ast.Ident) *Alloc {
return f.addNamedLocal(f.Pkg.info.Defs[id], id)
}
// addLocal creates an anonymous local variable of type typ, adds it
// to function f and returns it. pos is the optional source location.
//
func (f *Function) addLocal(typ types.Type, source ast.Node) *Alloc {
v := &Alloc{}
v.setType(types.NewPointer(typ))
f.Locals = append(f.Locals, v)
f.emit(v, source)
return v
}
// 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.
//
func (f *Function) lookup(obj types.Object, escaping bool) Value {
if v, ok := f.objects[obj]; ok {
if alloc, ok := v.(*Alloc); ok && escaping {
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.objects[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, params []*Parameter) {
buf.WriteString("func ")
if recv := sig.Recv(); recv != nil {
buf.WriteString("(")
if n := params[0].Name(); n != "" {
buf.WriteString(n)
buf.WriteString(" ")
}
types.WriteType(buf, params[0].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, f.Params)
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())
}
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, "")
}
}
go-tools-2021.1.2/go/ir/html.go 0000664 0000000 0000000 00000067077 14143223131 0016027 0 ustar 00root root 0000000 0000000 // 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(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)
} 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))
}
// 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, ")
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),
}
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
}
go-tools-2021.1.2/go/ir/irutil/load_test.go 0000664 0000000 0000000 00000006011 14143223131 0020326 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, 0)
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.LoadSyntax}
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 = Parameter <[]byte> {buf}
t2 = HeapAlloc <*Buffer>
t3 = FieldAddr <*[]byte> [0] (buf) t2
Store {[]byte} t3 t1
Jump β b1
b1: β b0 # exit
Return t2
`[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"`, 0)
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.LoadSyntax}
pkgs, err := packages.Load(cfg, "runtime")
if err != nil {
t.Fatal(err)
}
prog, _ := irutil.Packages(pkgs, 0, nil)
prog.Build() // no crash
}
go-tools-2021.1.2/go/ir/irutil/loops.go 0000664 0000000 0000000 00000002024 14143223131 0017504 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
}
go-tools-2021.1.2/go/ir/irutil/stub.go 0000664 0000000 0000000 00000001515 14143223131 0017331 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
}
go-tools-2021.1.2/go/ir/irutil/switch.go 0000664 0000000 0000000 00000016437 14143223131 0017666 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
}
go-tools-2021.1.2/go/ir/irutil/switch_test.go 0000664 0000000 0000000 00000005107 14143223131 0020715 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.
// +build !android
package irutil
import (
"bytes"
"fmt"
"go/parser"
"strings"
"testing"
"honnef.co/go/tools/go/ir"
"golang.org/x/tools/go/loader"
)
func TestSwitches(t *testing.T) {
conf := loader.Config{ParserMode: parser.ParseComments}
f, err := conf.ParseFile("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()
}
go-tools-2021.1.2/go/ir/irutil/terminates.go 0000664 0000000 0000000 00000003014 14143223131 0020523 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
}
go-tools-2021.1.2/go/ir/irutil/testdata/ 0000775 0000000 0000000 00000000000 14143223131 0017634 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/go/ir/irutil/testdata/switches.go 0000664 0000000 0000000 00000010766 14143223131 0022026 0 ustar 00root root 0000000 0000000 // +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 t8 {
// case t1: Call <()> print t1
// case t2: Call <()> print t4
// case t3: Call <()> print t4
// default: BinOp {==} t26 t27
// }
// switch t32 {
// case t5: Call <()> print t5
// case t6: Call <()> print t6
// default: Call <()> print t7
// }
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 t12 {
// case t1: Call <()> print t4
// case t2: Call <()> print t4
// default: BinOp {<} t27 t3
// }
if x == 1 || 2 == x || x < 5 {
print(12)
}
// switch t24 {
// case t5: Call <()> print t7
// case t6: Call <()> print t7
// default: BinOp {==} t49 t50
// }
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 t4 {
// case t1: Call <()> print t1
// case t2: Call <()> print t2
// default: Call <()> print t3
// }
if x == 1 {
print(1)
} else if x == 2 {
print(2)
} else {
print("else")
}
}
func GotoBasedSwitch(x int) {
// switch t4 {
// case t1: Call <()> print t1
// case t2: Call <()> print t2
// 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 t11 {
// case t2: Call <()> print t2
// case t3: Call <()> print t3
// default: BinOp {==} t29 t28
// }
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 t8 {
// case t2: Call <()> print t2
// case t3: Call <()> print t3
// default: BinOp {==} t8 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 t8 {
// case t1: Call <()> print t1
// case t2: BinOp {==} t8 t1
// default: Call <()> print t3
// }
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 t4 {
// case t1: Call <()> print t1
// case t1: Call <()> print t2
// case t3: Call <()> print t3
// 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 t5 {
// case t4: Call <()> print t1
// case t2: Call <()> print t2
// default: Call <()> print t3
// }
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")
}
}
go-tools-2021.1.2/go/ir/irutil/util.go 0000664 0000000 0000000 00000005572 14143223131 0017340 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
slice, ok := x.X.(*ir.Alloc)
if !ok {
return nil, false
}
for _, ref := range *slice.Referrers() {
if ref == x {
continue
}
if ref.Block() != x.Block() {
return nil, false
}
idx, ok := ref.(*ir.IndexAddr)
if !ok {
return nil, false
}
if len(*idx.Referrers()) != 1 {
return nil, false
}
store, ok := (*idx.Referrers())[0].(*ir.Store)
if !ok {
return nil, false
}
out = append(out, store.Val)
}
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
}
go-tools-2021.1.2/go/ir/irutil/visit.go 0000664 0000000 0000000 00000003766 14143223131 0017524 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
}
go-tools-2021.1.2/go/ir/lift.go 0000664 0000000 0000000 00000065314 14143223131 0016011 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...
// http://doi.acm.org/10.1145/115372.115320
//
// Cooper, Harvey, Kennedy. 2001. A Simple, Fast Dominance Algorithm.
// Software Practice and Experience 2001, 4:1-10.
// http://www.hipersoft.rice.edu/grads/publications/dom14.pdf
//
// Daniel Berlin, llvmdev mailing list, 2012.
// http://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 (
"fmt"
"go/types"
"os"
)
// 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 [][]*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 [][]*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 {
i := 0
for _, ref := range refs {
if ref == instr {
continue
}
refs[i] = ref
i++
}
for j := i; j != len(refs); j++ {
refs[j] = nil // aid GC
}
return refs[:i]
}
func clearInstrs(instrs []Instruction) {
for i := range instrs {
instrs[i] = nil
}
}
// 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) {
// 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 newPhiMap
var newSigmas newSigmaMap
// 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 in functions that contain no 'defer'
// instructions.
usesDefer := false
// Determine which allocs we can lift and number them densely.
// The renaming phase uses this numbering for compact maps.
numAllocs := 0
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) {
instr.index = -1
continue
}
index := -1
if numAllocs == 0 {
df = buildDomFrontier(fn)
rdf = buildPostDomFrontier(fn)
if len(fn.Blocks) > 2 {
closure = transitiveClosure(fn)
}
newPhis = make(newPhiMap, len(fn.Blocks))
newSigmas = make(newSigmaMap, 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)
}
}
}
}
liftAlloc(closure, df, rdf, instr, newPhis, newSigmas)
index = numAllocs
numAllocs++
instr.index = index
case *Defer:
usesDefer = true
case *RunDefers:
b.rundefers++
}
}
}
if numAllocs > 0 {
// 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)
simplifyPhis(newPhis)
// Eliminate dead Ο- and Ο-nodes.
markLiveNodes(fn.Blocks, newPhis, newSigmas)
}
// 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]
}
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 newPhiMap, newSigmas newSigmaMap) {
// 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)
}
}
}
// simplifyPhis 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 simplifyPhis(newPhis newPhiMap) {
// 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 simplifyPhis
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
}
}
}
}
for _, npList := range newPhis {
for _, np := range npList {
np.phi.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 []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) {
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([]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<= 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.
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 {
// XXX add debugging
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)
}
}
go-tools-2021.1.2/go/ir/lvalue.go 0000664 0000000 0000000 00000005626 14143223131 0016343 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())
}
// 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 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")
}
go-tools-2021.1.2/go/ir/methods.go 0000664 0000000 0000000 00000014525 14143223131 0016514 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"
)
// 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 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).(*methodSet)
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 interface{}) {
if v.(*methodSet).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 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).(bool); 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 && !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:
// 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)
}
default:
panic(T)
}
}
go-tools-2021.1.2/go/ir/mode.go 0000664 0000000 0000000 00000005135 14143223131 0015772 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
)
const BuilderModeDoc = `Options controlling the IR builder.
The value is a sequence of zero or more of these letters:
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.
`
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')
}
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
default:
return fmt.Errorf("unknown BuilderMode option: %q", c)
}
}
*m = mode
return nil
}
// Get returns m.
func (m BuilderMode) Get() interface{} { return m }
go-tools-2021.1.2/go/ir/print.go 0000664 0000000 0000000 00000030705 14143223131 0016203 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"
"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 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.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 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 *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()
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()
}
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 := 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 (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 {
return printCall(&s.Call, "Defer", s)
}
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")
}
go-tools-2021.1.2/go/ir/sanity.go 0000664 0000000 0000000 00000035106 14143223131 0016356 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 (
"fmt"
"go/types"
"io"
"os"
"strings"
)
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 '%v' has no value for edge #%d from %s", instr, 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 *Convert:
if _, ok := instr.X.Type().Underlying().(*types.Basic); !ok {
if _, ok := instr.Type().Underlying().(*types.Basic); !ok {
s.errorf("convert %s -> %s: at least one type must be basic", instr.X.Type(), instr.Type())
}
}
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 *Recv:
case *TypeSwitch:
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 t == tRangeIter {
// not a proper type; ignore.
} 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 := (*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")
}
_ = fn.String() // must not crash
_ = fn.RelString(fn.pkg()) // 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:
default:
if !strings.HasSuffix(fn.name, "Error") {
s.errorf("nil Pkg")
}
}
}
if src, syn := fn.Synthetic == 0, fn.source != nil; src != syn {
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))
}
}
}
}
go-tools-2021.1.2/go/ir/source.go 0000664 0000000 0000000 00000020654 14143223131 0016351 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 {
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())
}
// Package-level named constant?
if v := prog.packageLevelValue(obj); v != nil {
return v.(*Const)
}
return NewConst(obj.Val(), obj.Type())
}
// 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
}
go-tools-2021.1.2/go/ir/source_test.go 0000664 0000000 0000000 00000026021 14143223131 0017402 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"
"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/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("testdata/objlookup.go")
if err != nil {
t.Fatal(err)
}
readFile := func(filename string) ([]byte, error) { return src, nil }
f, err := conf.ParseFile("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, "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, " {+} t1 t2" (BinOp)
// "Call len t1" (Call)
// Note that the name of the Value is not printed.
//
// Examples of Instructions that are not Values:
// "Return t1" (Return)
// "Store {int} t2 t1" (Store)
//
// (The separation of Value.Name() from Value.String() is useful
// for some analyses which distinguish the operation from the
// value it defines, e.g., 'y = local int' is both an allocation
// of memory 'local int' and a definition of a pointer y.)
String() string
// ID returns the ID of this instruction. IDs are unique within a single
// function and are densely numbered, but may contain gaps.
// Globally, instructions are identified by their addresses. However,
// IDs exist to facilitate efficient storage of mappings between
// instructions and data when analysing functions.
//
// NB: IDs are allocated late in the IR construction process and
// are not available to early stages of said process.
ID() ID
// Parent returns the function to which this instruction
// belongs.
Parent() *Function
// Block returns the basic block to which this instruction
// belongs.
Block() *BasicBlock
// setBlock sets the basic block to which this instruction belongs.
setBlock(*BasicBlock)
// Operands returns the operands of this instruction: the
// set of Values it references.
//
// Specifically, it appends their addresses to rands, a
// user-provided slice, and returns the resulting slice,
// permitting avoidance of memory allocation.
//
// The operands are appended in undefined order, but the order
// is consistent for a given Instruction; the addresses are
// always non-nil but may point to a nil Value. Clients may
// store through the pointers, e.g. to effect a value
// renaming.
//
// Value.Referrers is a subset of the inverse of this
// relation. (Referrers are not tracked for all types of
// Values.)
Operands(rands []*Value) []*Value
Referrers() *[]Instruction // nil for non-Values
// Source returns the AST node responsible for creating this
// instruction. A single AST node may be responsible for more than
// one instruction, and not all instructions have an associated
// AST node.
Source() ast.Node
// Pos returns Source().Pos() if Source is not nil, else it
// returns token.NoPos.
Pos() token.Pos
}
// A Node is a node in the IR value graph. Every concrete type that
// implements Node is also either a Value, an Instruction, or both.
//
// Node contains the methods common to Value and Instruction, plus the
// Operands and Referrers methods generalized to return nil for
// non-Instructions and non-Values, respectively.
//
// Node is provided to simplify IR graph algorithms. Clients should
// use the more specific and informative Value or Instruction
// interfaces where appropriate.
//
type Node interface {
setID(ID)
// Common methods:
ID() ID
String() string
Source() ast.Node
Pos() token.Pos
Parent() *Function
// Partial methods:
Operands(rands []*Value) []*Value // nil for non-Instructions
Referrers() *[]Instruction // nil for non-Values
}
type Synthetic int
const (
SyntheticLoadedFromExportData Synthetic = iota + 1
SyntheticPackageInitializer
SyntheticThunk
SyntheticWrapper
SyntheticBound
)
func (syn Synthetic) String() string {
switch syn {
case SyntheticLoadedFromExportData:
return "loaded from export data"
case SyntheticPackageInitializer:
return "package initializer"
case SyntheticThunk:
return "thunk"
case SyntheticWrapper:
return "wrapper"
case SyntheticBound:
return "bound"
default:
return fmt.Sprintf("Synthetic(%d)", syn)
}
}
// Function represents the parameters, results, and code of a function
// or method.
//
// If Blocks is nil, this indicates an external function for which no
// Go source code is available. In this case, FreeVars and Locals
// are nil too. Clients performing whole-program analysis must
// handle external functions specially.
//
// Blocks contains the function's control-flow graph (CFG).
// Blocks[0] is the function entry point; block order is not otherwise
// semantically significant, though it may affect the readability of
// the disassembly.
// To iterate over the blocks in dominance order, use DomPreorder().
//
// A nested function (Parent()!=nil) that refers to one or more
// lexically enclosing local variables ("free variables") has FreeVars.
// Such functions cannot be called directly but require a
// value created by MakeClosure which, via its Bindings, supplies
// values for these parameters.
//
// If the function is a method (Signature.Recv() != nil) then the first
// element of Params is the receiver parameter.
//
// A Go package may declare many functions called "init".
// For each one, Object().Name() returns "init" but Name() returns
// "init#1", etc, in declaration order.
//
// Pos() returns the declaring ast.FuncLit.Type.Func or the position
// of the ast.FuncDecl.Name, if the function was explicit in the
// source. Synthetic wrappers, for which Synthetic != "", may share
// the same position as the function they wrap.
// Syntax.Pos() always returns the position of the declaring "func" token.
//
// Type() returns the function's Signature.
//
type Function struct {
node
name string
object types.Object // a declared *types.Func or one of its wrappers
method *types.Selection // info about provenance of synthetic methods
Signature *types.Signature
Synthetic Synthetic
parent *Function // enclosing function if anon; nil if global
Pkg *Package // enclosing package; nil for shared funcs (wrappers and error.Error)
Prog *Program // enclosing program
Params []*Parameter // function parameters; for methods, includes receiver
FreeVars []*FreeVar // free variables whose values must be supplied by closure
Locals []*Alloc // local variables of this function
Blocks []*BasicBlock // basic blocks of the function; nil => external
Exit *BasicBlock // The function's exit block
AnonFuncs []*Function // anonymous functions directly beneath this one
referrers []Instruction // referring instructions (iff Parent() != nil)
NoReturn NoReturn // Calling this function will always terminate control flow.
*functionBody
}
type NoReturn uint8
const (
Returns NoReturn = iota
AlwaysExits
AlwaysUnwinds
NeverReturns
)
type functionBody struct {
// The following fields are set transiently during building,
// then cleared.
currentBlock *BasicBlock // where to emit code
objects map[types.Object]Value // addresses of local variables
namedResults []*Alloc // tuple of named results
implicitResults []*Alloc // tuple of results
targets *targets // linked stack of branch targets
lblocks map[*ast.Object]*lblock // labelled blocks
consts []*Const
wr *HTMLWriter
fakeExits BlockSet
blocksets [5]BlockSet
hasDefer bool
// a contiguous block of instructions that will be used by blocks,
// to avoid making multiple allocations.
scratchInstructions []Instruction
}
func (fn *Function) results() []*Alloc {
if len(fn.namedResults) > 0 {
return fn.namedResults
}
return fn.implicitResults
}
// BasicBlock represents an IR basic block.
//
// The final element of Instrs is always an explicit transfer of
// control (If, Jump, Return, Panic, or Unreachable).
//
// A block may contain no Instructions only if it is unreachable,
// i.e., Preds is nil. Empty blocks are typically pruned.
//
// BasicBlocks and their Preds/Succs relation form a (possibly cyclic)
// graph independent of the IR Value graph: the control-flow graph or
// CFG. It is illegal for multiple edges to exist between the same
// pair of blocks.
//
// Each BasicBlock is also a node in the dominator tree of the CFG.
// The tree may be navigated using Idom()/Dominees() and queried using
// Dominates().
//
// The order of Preds and Succs is significant (to Phi and If
// instructions, respectively).
//
type BasicBlock struct {
Index int // index of this block within Parent().Blocks
Comment string // optional label; no semantic significance
parent *Function // parent function
Instrs []Instruction // instructions in order
Preds, Succs []*BasicBlock // predecessors and successors
succs2 [2]*BasicBlock // initial space for Succs
dom domInfo // dominator tree info
pdom domInfo // post-dominator tree info
post int
gaps int // number of nil Instrs (transient)
rundefers int // number of rundefers (transient)
}
// Pure values ----------------------------------------
// A FreeVar represents a free variable of the function to which it
// belongs.
//
// FreeVars are used to implement anonymous functions, whose free
// variables are lexically captured in a closure formed by
// MakeClosure. The value of such a free var is an Alloc or another
// FreeVar and is considered a potentially escaping heap address, with
// pointer type.
//
// FreeVars are also used to implement bound method closures. Such a
// free var represents the receiver value and may be of any type that
// has concrete methods.
//
// Pos() returns the position of the value that was captured, which
// belongs to an enclosing function.
//
type FreeVar struct {
node
name string
typ types.Type
parent *Function
referrers []Instruction
// Transiently needed during building.
outer Value // the Value captured from the enclosing context.
}
// A Parameter represents an input parameter of a function.
//
type Parameter struct {
register
name string
object types.Object // a *types.Var; nil for non-source locals
}
// A Const represents the value of a constant expression.
//
// The underlying type of a constant may be any boolean, numeric, or
// string type. In addition, a Const may represent the nil value of
// any reference type---interface, map, channel, pointer, slice, or
// function---but not "untyped nil".
//
// All source-level constant expressions are represented by a Const
// of the same type and value.
//
// Value holds the exact value of the constant, independent of its
// Type(), using the same representation as package go/constant uses for
// constants, or nil for a typed nil value.
//
// Pos() returns token.NoPos.
//
// Example printed form:
// Const {42}
// Const {"test"}
// Const {(3 + 4i)}
//
type Const struct {
register
Value constant.Value
}
// A Global is a named Value holding the address of a package-level
// variable.
//
// Pos() returns the position of the ast.ValueSpec.Names[*]
// identifier.
//
type Global struct {
node
name string
object types.Object // a *types.Var; may be nil for synthetics e.g. init$guard
typ types.Type
Pkg *Package
}
// A Builtin represents a specific use of a built-in function, e.g. len.
//
// Builtins are immutable values. Builtins do not have addresses.
// Builtins can only appear in CallCommon.Func.
//
// Name() indicates the function: one of the built-in functions from the
// Go spec (excluding "make" and "new") or one of these ir-defined
// intrinsics:
//
// // wrapnilchk returns ptr if non-nil, panics otherwise.
// // (For use in indirection wrappers.)
// func ir:wrapnilchk(ptr *T, recvType, methodName string) *T
//
// // noreturnWasPanic returns true if the previously called
// // function panicked, false if it exited the process.
// func ir:noreturnWasPanic() bool
//
// Object() returns a *types.Builtin for built-ins defined by the spec,
// nil for others.
//
// Type() returns a *types.Signature representing the effective
// signature of the built-in for this call.
//
type Builtin struct {
node
name string
sig *types.Signature
}
// Value-defining instructions ----------------------------------------
// The Alloc instruction reserves space for a variable of the given type,
// zero-initializes it, and yields its address.
//
// Alloc values are always addresses, and have pointer types, so the
// type of the allocated variable is actually
// Type().Underlying().(*types.Pointer).Elem().
//
// If Heap is false, Alloc allocates space in the function's
// activation record (frame); we refer to an Alloc(Heap=false) as a
// "stack" alloc. Each stack Alloc returns the same address each time
// it is executed within the same activation; the space is
// re-initialized to zero.
//
// If Heap is true, Alloc allocates space in the heap; we
// refer to an Alloc(Heap=true) as a "heap" alloc. Each heap Alloc
// returns a different address each time it is executed.
//
// When Alloc is applied to a channel, map or slice type, it returns
// the address of an uninitialized (nil) reference of that kind; store
// the result of MakeSlice, MakeMap or MakeChan in that location to
// instantiate these types.
//
// Pos() returns the ast.CompositeLit.Lbrace for a composite literal,
// or the ast.CallExpr.Rparen for a call to new() or for a call that
// allocates a varargs slice.
//
// Example printed form:
// t1 = StackAlloc <*int>
// t2 = HeapAlloc <*int> (new)
//
type Alloc struct {
register
Heap bool
index int // dense numbering; for lifting
}
var _ Instruction = (*Sigma)(nil)
var _ Value = (*Sigma)(nil)
// The Sigma instruction represents an SSI Ο-node, which splits values
// at branches in the control flow.
//
// Conceptually, Ο-nodes exist at the end of blocks that branch and
// constitute parallel assignments to one value per destination block.
// However, such a representation would be awkward to work with, so
// instead we place Ο-nodes at the beginning of branch targets. The
// From field denotes to which incoming edge the node applies.
//
// Within a block, all Ο-nodes must appear before all non-Ο nodes.
//
// Example printed form:
// t2 = Sigma [#0] t1 (x)
//
type Sigma struct {
register
From *BasicBlock
X Value
live bool // used during lifting
}
// The Phi instruction represents an SSA Ο-node, which combines values
// that differ across incoming control-flow edges and yields a new
// value. Within a block, all Ο-nodes must appear before all non-Ο, non-Ο
// nodes.
//
// Pos() returns the position of the && or || for short-circuit
// control-flow joins, or that of the *Alloc for Ο-nodes inserted
// during SSA renaming.
//
// Example printed form:
// t3 = Phi 2:t1 4:t2 (x)
//
type Phi struct {
register
Edges []Value // Edges[i] is value for Block().Preds[i]
live bool // used during lifting
}
// The Call instruction represents a function or method call.
//
// The Call instruction yields the function result if there is exactly
// one. Otherwise it returns a tuple, the components of which are
// accessed via Extract.
//
// See CallCommon for generic function call documentation.
//
// Pos() returns the ast.CallExpr.Lparen, if explicit in the source.
//
// Example printed form:
// t3 = Call <()> println t1 t2
// t4 = Call <()> foo$1
// t6 = Invoke t5.String
//
type Call struct {
register
Call CallCommon
}
// The BinOp instruction yields the result of binary operation X Op Y.
//
// Pos() returns the ast.BinaryExpr.OpPos, if explicit in the source.
//
// Example printed form:
// t3 = BinOp {+} t2 t1
//
type BinOp struct {
register
// One of:
// ADD SUB MUL QUO REM + - * / %
// AND OR XOR SHL SHR AND_NOT & | ^ << >> &^
// EQL NEQ LSS LEQ GTR GEQ == != < <= < >=
Op token.Token
X, Y Value
}
// The UnOp instruction yields the result of Op X.
// XOR is bitwise complement.
// SUB is negation.
// NOT is logical negation.
//
//
// Example printed form:
// t2 = UnOp {^} t1
//
type UnOp struct {
register
Op token.Token // One of: NOT SUB XOR ! - ^
X Value
}
// The Load instruction loads a value from a memory address.
//
// For implicit memory loads, Pos() returns the position of the
// most closely associated source-level construct; the details are not
// specified.
//
// Example printed form:
// t2 = Load t1
//
type Load struct {
register
X Value
}
// The ChangeType instruction applies to X a value-preserving type
// change to Type().
//
// Type changes are permitted:
// - between a named type and its underlying type.
// - between two named types of the same underlying type.
// - between (possibly named) pointers to identical base types.
// - from a bidirectional channel to a read- or write-channel,
// optionally adding/removing a name.
//
// This operation cannot fail dynamically.
//
// Pos() returns the ast.CallExpr.Lparen, if the instruction arose
// from an explicit conversion in the source.
//
// Example printed form:
// t2 = ChangeType <*T> t1
//
type ChangeType struct {
register
X Value
}
// The Convert instruction yields the conversion of value X to type
// Type(). One or both of those types is basic (but possibly named).
//
// A conversion may change the value and representation of its operand.
// Conversions are permitted:
// - between real numeric types.
// - between complex numeric types.
// - between string and []byte or []rune.
// - between pointers and unsafe.Pointer.
// - between unsafe.Pointer and uintptr.
// - from (Unicode) integer to (UTF-8) string.
// A conversion may imply a type name change also.
//
// This operation cannot fail dynamically.
//
// Conversions of untyped string/number/bool constants to a specific
// representation are eliminated during IR construction.
//
// Pos() returns the ast.CallExpr.Lparen, if the instruction arose
// from an explicit conversion in the source.
//
// Example printed form:
// t2 = Convert <[]byte> t1
//
type Convert struct {
register
X Value
}
// ChangeInterface constructs a value of one interface type from a
// value of another interface type known to be assignable to it.
// This operation cannot fail.
//
// Pos() returns the ast.CallExpr.Lparen if the instruction arose from
// an explicit T(e) conversion; the ast.TypeAssertExpr.Lparen if the
// instruction arose from an explicit e.(T) operation; or token.NoPos
// otherwise.
//
// Example printed form:
// t2 = ChangeInterface t1
//
type ChangeInterface struct {
register
X Value
}
// The SliceToArrayPointer instruction yields the conversion of slice X to
// array pointer.
//
// Pos() returns the ast.CallExpr.Lparen, if the instruction arose
// from an explicit conversion in the source.
//
// Example printed form:
// t1 = SliceToArrayPointer <*[4]byte> t1
//
type SliceToArrayPointer struct {
register
X Value
}
// MakeInterface constructs an instance of an interface type from a
// value of a concrete type.
//
// Use Program.MethodSets.MethodSet(X.Type()) to find the method-set
// of X, and Program.MethodValue(m) to find the implementation of a method.
//
// To construct the zero value of an interface type T, use:
// NewConst(constant.MakeNil(), T, pos)
//
// Pos() returns the ast.CallExpr.Lparen, if the instruction arose
// from an explicit conversion in the source.
//
// Example printed form:
// t2 = MakeInterface t1
//
type MakeInterface struct {
register
X Value
}
// The MakeClosure instruction yields a closure value whose code is
// Fn and whose free variables' values are supplied by Bindings.
//
// Type() returns a (possibly named) *types.Signature.
//
// Pos() returns the ast.FuncLit.Type.Func for a function literal
// closure or the ast.SelectorExpr.Sel for a bound method closure.
//
// Example printed form:
// t1 = MakeClosure foo$1 t1 t2
// t5 = MakeClosure (T).foo$bound t4
//
type MakeClosure struct {
register
Fn Value // always a *Function
Bindings []Value // values for each free variable in Fn.FreeVars
}
// The MakeMap instruction creates a new hash-table-based map object
// and yields a value of kind map.
//
// Type() returns a (possibly named) *types.Map.
//
// Pos() returns the ast.CallExpr.Lparen, if created by make(map), or
// the ast.CompositeLit.Lbrack if created by a literal.
//
// Example printed form:
// t1 = MakeMap
// t2 = MakeMap t1
//
type MakeMap struct {
register
Reserve Value // initial space reservation; nil => default
}
// The MakeChan instruction creates a new channel object and yields a
// value of kind chan.
//
// Type() returns a (possibly named) *types.Chan.
//
// Pos() returns the ast.CallExpr.Lparen for the make(chan) that
// created it.
//
// Example printed form:
// t3 = MakeChan t1
// t4 = MakeChan t2
//
type MakeChan struct {
register
Size Value // int; size of buffer; zero => synchronous.
}
// The MakeSlice instruction yields a slice of length Len backed by a
// newly allocated array of length Cap.
//
// Both Len and Cap must be non-nil Values of integer type.
//
// (Alloc(types.Array) followed by Slice will not suffice because
// Alloc can only create arrays of constant length.)
//
// Type() returns a (possibly named) *types.Slice.
//
// Pos() returns the ast.CallExpr.Lparen for the make([]T) that
// created it.
//
// Example printed form:
// t3 = MakeSlice <[]string> t1 t2
// t4 = MakeSlice t1 t2
//
type MakeSlice struct {
register
Len Value
Cap Value
}
// The Slice instruction yields a slice of an existing string, slice
// or *array X between optional integer bounds Low and High.
//
// Dynamically, this instruction panics if X evaluates to a nil *array
// pointer.
//
// Type() returns string if the type of X was string, otherwise a
// *types.Slice with the same element type as X.
//
// Pos() returns the ast.SliceExpr.Lbrack if created by a x[:] slice
// operation, the ast.CompositeLit.Lbrace if created by a literal, or
// NoPos if not explicit in the source (e.g. a variadic argument slice).
//
// Example printed form:
// t4 = Slice <[]int> t3 t2 t1
//
type Slice struct {
register
X Value // slice, string, or *array
Low, High, Max Value // each may be nil
}
// The FieldAddr instruction yields the address of Field of *struct X.
//
// The field is identified by its index within the field list of the
// struct type of X.
//
// Dynamically, this instruction panics if X evaluates to a nil
// pointer.
//
// Type() returns a (possibly named) *types.Pointer.
//
// Pos() returns the position of the ast.SelectorExpr.Sel for the
// field, if explicit in the source.
//
// Example printed form:
// t2 = FieldAddr <*int> [0] (X) t1
//
type FieldAddr struct {
register
X Value // *struct
Field int // field is X.Type().Underlying().(*types.Pointer).Elem().Underlying().(*types.Struct).Field(Field)
}
// The Field instruction yields the Field of struct X.
//
// The field is identified by its index within the field list of the
// struct type of X; by using numeric indices we avoid ambiguity of
// package-local identifiers and permit compact representations.
//
// Pos() returns the position of the ast.SelectorExpr.Sel for the
// field, if explicit in the source.
//
// Example printed form:
// t2 = FieldAddr [0] (X) t1
//
type Field struct {
register
X Value // struct
Field int // index into X.Type().(*types.Struct).Fields
}
// The IndexAddr instruction yields the address of the element at
// index Index of collection X. Index is an integer expression.
//
// The elements of maps and strings are not addressable; use StringLookup, MapLookup or
// MapUpdate instead.
//
// Dynamically, this instruction panics if X evaluates to a nil *array
// pointer.
//
// Type() returns a (possibly named) *types.Pointer.
//
// Pos() returns the ast.IndexExpr.Lbrack for the index operation, if
// explicit in the source.
//
// Example printed form:
// t3 = IndexAddr <*int> t2 t1
//
type IndexAddr struct {
register
X Value // slice or *array,
Index Value // numeric index
}
// The Index instruction yields element Index of array X.
//
// Pos() returns the ast.IndexExpr.Lbrack for the index operation, if
// explicit in the source.
//
// Example printed form:
// t3 = Index t2 t1
//
type Index struct {
register
X Value // array
Index Value // integer index
}
// The MapLookup instruction yields element Index of collection X, a map.
//
// If CommaOk, the result is a 2-tuple of the value above and a
// boolean indicating the result of a map membership test for the key.
// The components of the tuple are accessed using Extract.
//
// Pos() returns the ast.IndexExpr.Lbrack, if explicit in the source.
//
// Example printed form:
// t4 = MapLookup t3 t1
// t6 = MapLookup <(string, bool)> t3 t2
//
type MapLookup struct {
register
X Value // map
Index Value // key-typed index
CommaOk bool // return a value,ok pair
}
// The StringLookup instruction yields element Index of collection X, a string.
// Index is an integer expression.
//
// Pos() returns the ast.IndexExpr.Lbrack, if explicit in the source.
//
// Example printed form:
// t3 = StringLookup t2 t1
//
type StringLookup struct {
register
X Value // string
Index Value // numeric index
}
// SelectState is a helper for Select.
// It represents one goal state and its corresponding communication.
//
type SelectState struct {
Dir types.ChanDir // direction of case (SendOnly or RecvOnly)
Chan Value // channel to use (for send or receive)
Send Value // value to send (for send)
Pos token.Pos // position of token.ARROW
DebugNode ast.Node // ast.SendStmt or ast.UnaryExpr(<-) [debug mode]
}
// The Select instruction tests whether (or blocks until) one
// of the specified sent or received states is entered.
//
// Let n be the number of States for which Dir==RECV and Tα΅’ (0 β€ i < n)
// be the element type of each such state's Chan.
// Select returns an n+2-tuple
// (index int, recvOk bool, rβ Tβ, ... rβ-1 Tβ-1)
// The tuple's components, described below, must be accessed via the
// Extract instruction.
//
// If Blocking, select waits until exactly one state holds, i.e. a
// channel becomes ready for the designated operation of sending or
// receiving; select chooses one among the ready states
// pseudorandomly, performs the send or receive operation, and sets
// 'index' to the index of the chosen channel.
//
// If !Blocking, select doesn't block if no states hold; instead it
// returns immediately with index equal to -1.
//
// If the chosen channel was used for a receive, the rα΅’ component is
// set to the received value, where i is the index of that state among
// all n receive states; otherwise rα΅’ has the zero value of type Tα΅’.
// Note that the receive index i is not the same as the state
// index index.
//
// The second component of the triple, recvOk, is a boolean whose value
// is true iff the selected operation was a receive and the receive
// successfully yielded a value.
//
// Pos() returns the ast.SelectStmt.Select.
//
// Example printed form:
// t6 = SelectNonBlocking <(index int, ok bool, int)> [<-t4, t5<-t1]
// t11 = SelectBlocking <(index int, ok bool)> []
//
type Select struct {
register
States []*SelectState
Blocking bool
}
// The Range instruction yields an iterator over the domain and range
// of X, which must be a string or map.
//
// Elements are accessed via Next.
//
// Type() returns an opaque and degenerate "rangeIter" type.
//
// Pos() returns the ast.RangeStmt.For.
//
// Example printed form:
// t2 = Range t1
//
type Range struct {
register
X Value // string or map
}
// The Next instruction reads and advances the (map or string)
// iterator Iter and returns a 3-tuple value (ok, k, v). If the
// iterator is not exhausted, ok is true and k and v are the next
// elements of the domain and range, respectively. Otherwise ok is
// false and k and v are undefined.
//
// Components of the tuple are accessed using Extract.
//
// The IsString field distinguishes iterators over strings from those
// over maps, as the Type() alone is insufficient: consider
// map[int]rune.
//
// Type() returns a *types.Tuple for the triple (ok, k, v).
// The types of k and/or v may be types.Invalid.
//
// Example printed form:
// t5 = Next <(ok bool, k int, v rune)> t2
// t5 = Next <(ok bool, k invalid type, v invalid type)> t2
//
type Next struct {
register
Iter Value
IsString bool // true => string iterator; false => map iterator.
}
// The TypeAssert instruction tests whether interface value X has type
// AssertedType.
//
// If !CommaOk, on success it returns v, the result of the conversion
// (defined below); on failure it panics.
//
// If CommaOk: on success it returns a pair (v, true) where v is the
// result of the conversion; on failure it returns (z, false) where z
// is AssertedType's zero value. The components of the pair must be
// accessed using the Extract instruction.
//
// If AssertedType is a concrete type, TypeAssert checks whether the
// dynamic type in interface X is equal to it, and if so, the result
// of the conversion is a copy of the value in the interface.
//
// If AssertedType is an interface, TypeAssert checks whether the
// dynamic type of the interface is assignable to it, and if so, the
// result of the conversion is a copy of the interface value X.
// If AssertedType is a superinterface of X.Type(), the operation will
// fail iff the operand is nil. (Contrast with ChangeInterface, which
// performs no nil-check.)
//
// Type() reflects the actual type of the result, possibly a
// 2-types.Tuple; AssertedType is the asserted type.
//
// Pos() returns the ast.CallExpr.Lparen if the instruction arose from
// an explicit T(e) conversion; the ast.TypeAssertExpr.Lparen if the
// instruction arose from an explicit e.(T) operation; or the
// ast.CaseClause.Case if the instruction arose from a case of a
// type-switch statement.
//
// Example printed form:
// t2 = TypeAssert t1
// t4 = TypeAssert <(value fmt.Stringer, ok bool)> t1
//
type TypeAssert struct {
register
X Value
AssertedType types.Type
CommaOk bool
}
// The Extract instruction yields component Index of Tuple.
//
// This is used to access the results of instructions with multiple
// return values, such as Call, TypeAssert, Next, Recv,
// MapLookup and others.
//
// Example printed form:
// t7 = Extract [1] (ok) t4
//
type Extract struct {
register
Tuple Value
Index int
}
// Instructions executed for effect. They do not yield a value. --------------------
// The Jump instruction transfers control to the sole successor of its
// owning block.
//
// A Jump must be the last instruction of its containing BasicBlock.
//
// Pos() returns NoPos.
//
// Example printed form:
// Jump β b1
//
type Jump struct {
anInstruction
Comment string
}
// The Unreachable pseudo-instruction signals that execution cannot
// continue after the preceding function call because it terminates
// the process.
//
// The instruction acts as a control instruction, jumping to the exit
// block. However, this jump will never execute.
//
// An Unreachable instruction must be the last instruction of its
// containing BasicBlock.
//
// Example printed form:
// Unreachable β b1
//
type Unreachable struct {
anInstruction
}
// The If instruction transfers control to one of the two successors
// of its owning block, depending on the boolean Cond: the first if
// true, the second if false.
//
// An If instruction must be the last instruction of its containing
// BasicBlock.
//
// Pos() returns the *ast.IfStmt, if explicit in the source.
//
// Example printed form:
// If t2 β b1 b2
//
type If struct {
anInstruction
Cond Value
}
type ConstantSwitch struct {
anInstruction
Tag Value
// Constant branch conditions. A nil Value denotes the (implicit
// or explicit) default branch.
Conds []Value
}
type TypeSwitch struct {
register
Tag Value
Conds []types.Type
}
// The Return instruction returns values and control back to the calling
// function.
//
// len(Results) is always equal to the number of results in the
// function's signature.
//
// If len(Results) > 1, Return returns a tuple value with the specified
// components which the caller must access using Extract instructions.
//
// There is no instruction to return a ready-made tuple like those
// returned by a "value,ok"-mode TypeAssert, MapLookup or Recv or
// a tail-call to a function with multiple result parameters.
//
// Return must be the last instruction of its containing BasicBlock.
// Such a block has no successors.
//
// Pos() returns the ast.ReturnStmt.Return, if explicit in the source.
//
// Example printed form:
// Return
// Return t1 t2
//
type Return struct {
anInstruction
Results []Value
}
// The RunDefers instruction pops and invokes the entire stack of
// procedure calls pushed by Defer instructions in this function.
//
// It is legal to encounter multiple 'rundefers' instructions in a
// single control-flow path through a function; this is useful in
// the combined init() function, for example.
//
// Pos() returns NoPos.
//
// Example printed form:
// RunDefers
//
type RunDefers struct {
anInstruction
}
// The Panic instruction initiates a panic with value X.
//
// A Panic instruction must be the last instruction of its containing
// BasicBlock, which must have one successor, the exit block.
//
// NB: 'go panic(x)' and 'defer panic(x)' do not use this instruction;
// they are treated as calls to a built-in function.
//
// Pos() returns the ast.CallExpr.Lparen if this panic was explicit
// in the source.
//
// Example printed form:
// Panic t1
//
type Panic struct {
anInstruction
X Value // an interface{}
}
// The Go instruction creates a new goroutine and calls the specified
// function within it.
//
// See CallCommon for generic function call documentation.
//
// Pos() returns the ast.GoStmt.Go.
//
// Example printed form:
// Go println t1
// Go t3
// GoInvoke t4.Bar t2
//
type Go struct {
anInstruction
Call CallCommon
}
// The Defer instruction pushes the specified call onto a stack of
// functions to be called by a RunDefers instruction or by a panic.
//
// See CallCommon for generic function call documentation.
//
// Pos() returns the ast.DeferStmt.Defer.
//
// Example printed form:
// Defer println t1
// Defer t3
// DeferInvoke t4.Bar t2
//
type Defer struct {
anInstruction
Call CallCommon
}
// The Send instruction sends X on channel Chan.
//
// Pos() returns the ast.SendStmt.Arrow, if explicit in the source.
//
// Example printed form:
// Send t2 t1
//
type Send struct {
anInstruction
Chan, X Value
}
// The Recv instruction receives from channel Chan.
//
// If CommaOk, the result is a 2-tuple of the value above
// and a boolean indicating the success of the receive. The
// components of the tuple are accessed using Extract.
//
// Pos() returns the ast.UnaryExpr.OpPos, if explicit in the source.
// For receive operations implicit in ranging over a channel,
// Pos() returns the ast.RangeStmt.For.
//
// Example printed form:
// t2 = Recv t1
// t3 = Recv <(int, bool)> t1
type Recv struct {
register
Chan Value
CommaOk bool
}
// The Store instruction stores Val at address Addr.
// Stores can be of arbitrary types.
//
// Pos() returns the position of the source-level construct most closely
// associated with the memory store operation.
// Since implicit memory stores are numerous and varied and depend upon
// implementation choices, the details are not specified.
//
// Example printed form:
// Store {int} t2 t1
//
type Store struct {
anInstruction
Addr Value
Val Value
}
// The BlankStore instruction is emitted for assignments to the blank
// identifier.
//
// BlankStore is a pseudo-instruction: it has no dynamic effect.
//
// Pos() returns NoPos.
//
// Example printed form:
// BlankStore t1
//
type BlankStore struct {
anInstruction
Val Value
}
// The MapUpdate instruction updates the association of Map[Key] to
// Value.
//
// Pos() returns the ast.KeyValueExpr.Colon or ast.IndexExpr.Lbrack,
// if explicit in the source.
//
// Example printed form:
// MapUpdate t3 t1 t2
//
type MapUpdate struct {
anInstruction
Map Value
Key Value
Value Value
}
// A DebugRef instruction maps a source-level expression Expr to the
// IR value X that represents the value (!IsAddr) or address (IsAddr)
// of that expression.
//
// DebugRef is a pseudo-instruction: it has no dynamic effect.
//
// Pos() returns Expr.Pos(), the start position of the source-level
// expression. This is not the same as the "designated" token as
// documented at Value.Pos(). e.g. CallExpr.Pos() does not return the
// position of the ("designated") Lparen token.
//
// DebugRefs are generated only for functions built with debugging
// enabled; see Package.SetDebugMode() and the GlobalDebug builder
// mode flag.
//
// DebugRefs are not emitted for ast.Idents referring to constants or
// predeclared identifiers, since they are trivial and numerous.
// Nor are they emitted for ast.ParenExprs.
//
// (By representing these as instructions, rather than out-of-band,
// consistency is maintained during transformation passes by the
// ordinary SSA renaming machinery.)
//
// Example printed form:
// ; *ast.CallExpr @ 102:9 is t5
// ; var x float64 @ 109:72 is x
// ; address of *ast.CompositeLit @ 216:10 is t0
//
type DebugRef struct {
anInstruction
Expr ast.Expr // the referring expression (never *ast.ParenExpr)
object types.Object // the identity of the source var/func
IsAddr bool // Expr is addressable and X is the address it denotes
X Value // the value or address of Expr
}
// Embeddable mix-ins and helpers for common parts of other structs. -----------
// register is a mix-in embedded by all IR values that are also
// instructions, i.e. virtual registers, and provides a uniform
// implementation of most of the Value interface: Value.Name() is a
// numbered register (e.g. "t0"); the other methods are field accessors.
//
// Temporary names are automatically assigned to each register on
// completion of building a function in IR form.
//
type register struct {
anInstruction
typ types.Type // type of virtual register
referrers []Instruction
}
type node struct {
source ast.Node
id ID
}
func (n *node) setID(id ID) { n.id = id }
func (n node) ID() ID { return n.id }
func (n *node) setSource(source ast.Node) { n.source = source }
func (n *node) Source() ast.Node { return n.source }
func (n *node) Pos() token.Pos {
if n.source != nil {
return n.source.Pos()
}
return token.NoPos
}
// anInstruction is a mix-in embedded by all Instructions.
// It provides the implementations of the Block and setBlock methods.
type anInstruction struct {
node
block *BasicBlock // the basic block of this instruction
}
// CallCommon is contained by Go, Defer and Call to hold the
// common parts of a function or method call.
//
// Each CallCommon exists in one of two modes, function call and
// interface method invocation, or "call" and "invoke" for short.
//
// 1. "call" mode: when Method is nil (!IsInvoke), a CallCommon
// represents an ordinary function call of the value in Value,
// which may be a *Builtin, a *Function or any other value of kind
// 'func'.
//
// Value may be one of:
// (a) a *Function, indicating a statically dispatched call
// to a package-level function, an anonymous function, or
// a method of a named type.
// (b) a *MakeClosure, indicating an immediately applied
// function literal with free variables.
// (c) a *Builtin, indicating a statically dispatched call
// to a built-in function.
// (d) any other value, indicating a dynamically dispatched
// function call.
// StaticCallee returns the identity of the callee in cases
// (a) and (b), nil otherwise.
//
// Args contains the arguments to the call. If Value is a method,
// Args[0] contains the receiver parameter.
//
// Example printed form:
// t3 = Call <()> println t1 t2
// Go t3
// Defer t3
//
// 2. "invoke" mode: when Method is non-nil (IsInvoke), a CallCommon
// represents a dynamically dispatched call to an interface method.
// In this mode, Value is the interface value and Method is the
// interface's abstract method. Note: an abstract method may be
// shared by multiple interfaces due to embedding; Value.Type()
// provides the specific interface used for this call.
//
// Value is implicitly supplied to the concrete method implementation
// as the receiver parameter; in other words, Args[0] holds not the
// receiver but the first true argument.
//
// Example printed form:
// t6 = Invoke t5.String
// GoInvoke t4.Bar t2
// DeferInvoke t4.Bar t2
//
// For all calls to variadic functions (Signature().Variadic()),
// the last element of Args is a slice.
//
type CallCommon struct {
Value Value // receiver (invoke mode) or func value (call mode)
Method *types.Func // abstract method (invoke mode)
Args []Value // actual parameters (in static method call, includes receiver)
Results Value
}
// IsInvoke returns true if this call has "invoke" (not "call") mode.
func (c *CallCommon) IsInvoke() bool {
return c.Method != nil
}
// Signature returns the signature of the called function.
//
// For an "invoke"-mode call, the signature of the interface method is
// returned.
//
// In either "call" or "invoke" mode, if the callee is a method, its
// receiver is represented by sig.Recv, not sig.Params().At(0).
//
func (c *CallCommon) Signature() *types.Signature {
if c.Method != nil {
return c.Method.Type().(*types.Signature)
}
return c.Value.Type().Underlying().(*types.Signature)
}
// StaticCallee returns the callee if this is a trivially static
// "call"-mode call to a function.
func (c *CallCommon) StaticCallee() *Function {
switch fn := c.Value.(type) {
case *Function:
return fn
case *MakeClosure:
return fn.Fn.(*Function)
}
return nil
}
// Description returns a description of the mode of this call suitable
// for a user interface, e.g., "static method call".
func (c *CallCommon) Description() string {
switch fn := c.Value.(type) {
case *Builtin:
return "built-in function call"
case *MakeClosure:
return "static function closure call"
case *Function:
if fn.Signature.Recv() != nil {
return "static method call"
}
return "static function call"
}
if c.IsInvoke() {
return "dynamic method call" // ("invoke" mode)
}
return "dynamic function call"
}
// The CallInstruction interface, implemented by *Go, *Defer and *Call,
// exposes the common parts of function-calling instructions,
// yet provides a way back to the Value defined by *Call alone.
//
type CallInstruction interface {
Instruction
Common() *CallCommon // returns the common parts of the call
Value() *Call
}
func (s *Call) Common() *CallCommon { return &s.Call }
func (s *Defer) Common() *CallCommon { return &s.Call }
func (s *Go) Common() *CallCommon { return &s.Call }
func (s *Call) Value() *Call { return s }
func (s *Defer) Value() *Call { return nil }
func (s *Go) Value() *Call { return nil }
func (v *Builtin) Type() types.Type { return v.sig }
func (v *Builtin) Name() string { return v.name }
func (*Builtin) Referrers() *[]Instruction { return nil }
func (v *Builtin) Pos() token.Pos { return token.NoPos }
func (v *Builtin) Object() types.Object { return types.Universe.Lookup(v.name) }
func (v *Builtin) Parent() *Function { return nil }
func (v *FreeVar) Type() types.Type { return v.typ }
func (v *FreeVar) Name() string { return v.name }
func (v *FreeVar) Referrers() *[]Instruction { return &v.referrers }
func (v *FreeVar) Parent() *Function { return v.parent }
func (v *Global) Type() types.Type { return v.typ }
func (v *Global) Name() string { return v.name }
func (v *Global) Parent() *Function { return nil }
func (v *Global) Referrers() *[]Instruction { return nil }
func (v *Global) Token() token.Token { return token.VAR }
func (v *Global) Object() types.Object { return v.object }
func (v *Global) String() string { return v.RelString(nil) }
func (v *Global) Package() *Package { return v.Pkg }
func (v *Global) RelString(from *types.Package) string { return relString(v, from) }
func (v *Function) Name() string { return v.name }
func (v *Function) Type() types.Type { return v.Signature }
func (v *Function) Token() token.Token { return token.FUNC }
func (v *Function) Object() types.Object { return v.object }
func (v *Function) String() string { return v.RelString(nil) }
func (v *Function) Package() *Package { return v.Pkg }
func (v *Function) Parent() *Function { return v.parent }
func (v *Function) Referrers() *[]Instruction {
if v.parent != nil {
return &v.referrers
}
return nil
}
func (v *Parameter) Object() types.Object { return v.object }
func (v *Alloc) Type() types.Type { return v.typ }
func (v *Alloc) Referrers() *[]Instruction { return &v.referrers }
func (v *register) Type() types.Type { return v.typ }
func (v *register) setType(typ types.Type) { v.typ = typ }
func (v *register) Name() string { return fmt.Sprintf("t%d", v.id) }
func (v *register) Referrers() *[]Instruction { return &v.referrers }
func (v *anInstruction) Parent() *Function { return v.block.parent }
func (v *anInstruction) Block() *BasicBlock { return v.block }
func (v *anInstruction) setBlock(block *BasicBlock) { v.block = block }
func (v *anInstruction) Referrers() *[]Instruction { return nil }
func (t *Type) Name() string { return t.object.Name() }
func (t *Type) Pos() token.Pos { return t.object.Pos() }
func (t *Type) Type() types.Type { return t.object.Type() }
func (t *Type) Token() token.Token { return token.TYPE }
func (t *Type) Object() types.Object { return t.object }
func (t *Type) String() string { return t.RelString(nil) }
func (t *Type) Package() *Package { return t.pkg }
func (t *Type) RelString(from *types.Package) string { return relString(t, from) }
func (c *NamedConst) Name() string { return c.object.Name() }
func (c *NamedConst) Pos() token.Pos { return c.object.Pos() }
func (c *NamedConst) String() string { return c.RelString(nil) }
func (c *NamedConst) Type() types.Type { return c.object.Type() }
func (c *NamedConst) Token() token.Token { return token.CONST }
func (c *NamedConst) Object() types.Object { return c.object }
func (c *NamedConst) Package() *Package { return c.pkg }
func (c *NamedConst) RelString(from *types.Package) string { return relString(c, from) }
// Func returns the package-level function of the specified name,
// or nil if not found.
//
func (p *Package) Func(name string) (f *Function) {
f, _ = p.Members[name].(*Function)
return
}
// Var returns the package-level variable of the specified name,
// or nil if not found.
//
func (p *Package) Var(name string) (g *Global) {
g, _ = p.Members[name].(*Global)
return
}
// Const returns the package-level constant of the specified name,
// or nil if not found.
//
func (p *Package) Const(name string) (c *NamedConst) {
c, _ = p.Members[name].(*NamedConst)
return
}
// Type returns the package-level type of the specified name,
// or nil if not found.
//
func (p *Package) Type(name string) (t *Type) {
t, _ = p.Members[name].(*Type)
return
}
func (s *DebugRef) Pos() token.Pos { return s.Expr.Pos() }
// Operands.
func (v *Alloc) Operands(rands []*Value) []*Value {
return rands
}
func (v *BinOp) Operands(rands []*Value) []*Value {
return append(rands, &v.X, &v.Y)
}
func (c *CallCommon) Operands(rands []*Value) []*Value {
rands = append(rands, &c.Value)
for i := range c.Args {
rands = append(rands, &c.Args[i])
}
return rands
}
func (s *Go) Operands(rands []*Value) []*Value {
return s.Call.Operands(rands)
}
func (s *Call) Operands(rands []*Value) []*Value {
return s.Call.Operands(rands)
}
func (s *Defer) Operands(rands []*Value) []*Value {
return s.Call.Operands(rands)
}
func (v *ChangeInterface) Operands(rands []*Value) []*Value {
return append(rands, &v.X)
}
func (v *ChangeType) Operands(rands []*Value) []*Value {
return append(rands, &v.X)
}
func (v *Convert) Operands(rands []*Value) []*Value {
return append(rands, &v.X)
}
func (v *SliceToArrayPointer) Operands(rands []*Value) []*Value {
return append(rands, &v.X)
}
func (s *DebugRef) Operands(rands []*Value) []*Value {
return append(rands, &s.X)
}
func (v *Extract) Operands(rands []*Value) []*Value {
return append(rands, &v.Tuple)
}
func (v *Field) Operands(rands []*Value) []*Value {
return append(rands, &v.X)
}
func (v *FieldAddr) Operands(rands []*Value) []*Value {
return append(rands, &v.X)
}
func (s *If) Operands(rands []*Value) []*Value {
return append(rands, &s.Cond)
}
func (s *ConstantSwitch) Operands(rands []*Value) []*Value {
rands = append(rands, &s.Tag)
for i := range s.Conds {
rands = append(rands, &s.Conds[i])
}
return rands
}
func (s *TypeSwitch) Operands(rands []*Value) []*Value {
rands = append(rands, &s.Tag)
return rands
}
func (v *Index) Operands(rands []*Value) []*Value {
return append(rands, &v.X, &v.Index)
}
func (v *IndexAddr) Operands(rands []*Value) []*Value {
return append(rands, &v.X, &v.Index)
}
func (*Jump) Operands(rands []*Value) []*Value {
return rands
}
func (*Unreachable) Operands(rands []*Value) []*Value {
return rands
}
func (v *MapLookup) Operands(rands []*Value) []*Value {
return append(rands, &v.X, &v.Index)
}
func (v *StringLookup) Operands(rands []*Value) []*Value {
return append(rands, &v.X, &v.Index)
}
func (v *MakeChan) Operands(rands []*Value) []*Value {
return append(rands, &v.Size)
}
func (v *MakeClosure) Operands(rands []*Value) []*Value {
rands = append(rands, &v.Fn)
for i := range v.Bindings {
rands = append(rands, &v.Bindings[i])
}
return rands
}
func (v *MakeInterface) Operands(rands []*Value) []*Value {
return append(rands, &v.X)
}
func (v *MakeMap) Operands(rands []*Value) []*Value {
return append(rands, &v.Reserve)
}
func (v *MakeSlice) Operands(rands []*Value) []*Value {
return append(rands, &v.Len, &v.Cap)
}
func (v *MapUpdate) Operands(rands []*Value) []*Value {
return append(rands, &v.Map, &v.Key, &v.Value)
}
func (v *Next) Operands(rands []*Value) []*Value {
return append(rands, &v.Iter)
}
func (s *Panic) Operands(rands []*Value) []*Value {
return append(rands, &s.X)
}
func (v *Sigma) Operands(rands []*Value) []*Value {
return append(rands, &v.X)
}
func (v *Phi) Operands(rands []*Value) []*Value {
for i := range v.Edges {
rands = append(rands, &v.Edges[i])
}
return rands
}
func (v *Range) Operands(rands []*Value) []*Value {
return append(rands, &v.X)
}
func (s *Return) Operands(rands []*Value) []*Value {
for i := range s.Results {
rands = append(rands, &s.Results[i])
}
return rands
}
func (*RunDefers) Operands(rands []*Value) []*Value {
return rands
}
func (v *Select) Operands(rands []*Value) []*Value {
for i := range v.States {
rands = append(rands, &v.States[i].Chan, &v.States[i].Send)
}
return rands
}
func (s *Send) Operands(rands []*Value) []*Value {
return append(rands, &s.Chan, &s.X)
}
func (recv *Recv) Operands(rands []*Value) []*Value {
return append(rands, &recv.Chan)
}
func (v *Slice) Operands(rands []*Value) []*Value {
return append(rands, &v.X, &v.Low, &v.High, &v.Max)
}
func (s *Store) Operands(rands []*Value) []*Value {
return append(rands, &s.Addr, &s.Val)
}
func (s *BlankStore) Operands(rands []*Value) []*Value {
return append(rands, &s.Val)
}
func (v *TypeAssert) Operands(rands []*Value) []*Value {
return append(rands, &v.X)
}
func (v *UnOp) Operands(rands []*Value) []*Value {
return append(rands, &v.X)
}
func (v *Load) Operands(rands []*Value) []*Value {
return append(rands, &v.X)
}
// Non-Instruction Values:
func (v *Builtin) Operands(rands []*Value) []*Value { return rands }
func (v *FreeVar) Operands(rands []*Value) []*Value { return rands }
func (v *Const) Operands(rands []*Value) []*Value { return rands }
func (v *Function) Operands(rands []*Value) []*Value { return rands }
func (v *Global) Operands(rands []*Value) []*Value { return rands }
func (v *Parameter) Operands(rands []*Value) []*Value { return rands }
go-tools-2021.1.2/go/ir/staticcheck.conf 0000664 0000000 0000000 00000000223 14143223131 0017644 0 ustar 00root root 0000000 0000000 # ssa/... is mostly imported from upstream and we don't want to
# deviate from it too much, hence disabling SA1019
checks = ["inherit", "-SA1019"]
go-tools-2021.1.2/go/ir/stdlib_test.go 0000664 0000000 0000000 00000007461 14143223131 0017372 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.
// Incomplete source tree on Android.
// +build !android
package ir_test
// This file runs the IR builder in sanity-checking mode on all
// packages beneath $GOROOT and prints some summary information.
//
// Run with "go test -cpu=8 to" set GOMAXPROCS.
import (
"go/ast"
"go/token"
"runtime"
"testing"
"time"
"honnef.co/go/tools/go/ir"
"honnef.co/go/tools/go/ir/irutil"
"golang.org/x/tools/go/packages"
)
func bytesAllocated() uint64 {
runtime.GC()
var stats runtime.MemStats
runtime.ReadMemStats(&stats)
return stats.TotalAlloc
}
func TestStdlib(t *testing.T) {
if testing.Short() {
t.Skip("skipping in short mode; too slow (golang.org/issue/14113)")
}
var (
numFuncs int
numInstrs int
dLoad time.Duration
dCreate time.Duration
dBuild time.Duration
allocLoad uint64
allocBuild uint64
)
// Load, parse and type-check the program.
t0 := time.Now()
alloc0 := bytesAllocated()
cfg := &packages.Config{
Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles | packages.NeedImports | packages.NeedDeps | packages.NeedTypes | packages.NeedSyntax | packages.NeedTypesInfo | packages.NeedTypesSizes,
}
pkgs, err := packages.Load(cfg, "std")
if err != nil {
t.Fatalf("Load failed: %v", err)
}
allocLoad = bytesAllocated() - alloc0
dLoad = time.Since(t0)
alloc0 = bytesAllocated()
for _, pkg := range pkgs {
if len(pkg.Errors) != 0 {
t.Fatalf("Load failed: %v", pkg.Errors)
}
var mode ir.BuilderMode
// Comment out these lines during benchmarking. Approx IR build costs are noted.
mode |= ir.SanityCheckFunctions // + 2% space, + 4% time
mode |= ir.GlobalDebug // +30% space, +18% time
prog := ir.NewProgram(pkg.Fset, mode)
t0 := time.Now()
var irpkg *ir.Package
for _, pkg2 := range pkgs {
r := prog.CreatePackage(pkg2.Types, pkg2.Syntax, pkg2.TypesInfo, true)
if pkg2 == pkg {
irpkg = r
}
}
dCreate += time.Since(t0)
t0 = time.Now()
irpkg.Build()
dBuild += time.Since(t0)
allFuncs := irutil.AllFunctions(prog)
numFuncs += len(allFuncs)
// Check that all non-synthetic functions have distinct names.
// Synthetic wrappers for exported methods should be distinct too,
// except for unexported ones (explained at (*Function).RelString).
byName := make(map[string]*ir.Function)
for fn := range allFuncs {
if fn.Synthetic == 0 || ast.IsExported(fn.Name()) {
str := fn.String()
prev := byName[str]
byName[str] = fn
if prev != nil {
t.Errorf("%s: duplicate function named %s",
prog.Fset.Position(fn.Pos()), str)
t.Errorf("%s: (previously defined here)",
prog.Fset.Position(prev.Pos()))
}
}
}
// Dump some statistics.
var numInstrs int
for fn := range allFuncs {
for _, b := range fn.Blocks {
numInstrs += len(b.Instrs)
}
}
}
allocBuild = bytesAllocated() - alloc0
// determine line count
var lineCount int
pkgs[0].Fset.Iterate(func(f *token.File) bool {
lineCount += f.LineCount()
return true
})
// NB: when benchmarking, don't forget to clear the debug +
// sanity builder flags for better performance.
t.Log("GOMAXPROCS: ", runtime.GOMAXPROCS(0))
t.Log("#Source lines: ", lineCount)
t.Log("Load/parse/typecheck: ", dLoad)
t.Log("IR create: ", dCreate)
t.Log("IR build: ", dBuild)
// IR stats:
t.Log("#Packages: ", len(pkgs))
t.Log("#Functions: ", numFuncs)
t.Log("#Instructions: ", numInstrs)
t.Log("#MB AST+types: ", allocLoad/1e6)
t.Log("#MB IR: ", allocBuild/1e6)
}
go-tools-2021.1.2/go/ir/testdata/ 0000775 0000000 0000000 00000000000 14143223131 0016324 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/go/ir/testdata/objlookup.go 0000664 0000000 0000000 00000011137 14143223131 0020662 0 ustar 00root root 0000000 0000000 //+build ignore
package main
// This file is the input to TestObjValueLookup in source_test.go,
// which ensures that each occurrence of an ident defining or
// referring to a func, var or const object can be mapped to its
// corresponding IR Value.
//
// For every reference to a var object, we use annotations in comments
// to denote both the expected IR Value kind, and whether to expect
// its value (x) or its address (&x).
//
// For const and func objects, the results don't vary by reference and
// are always values not addresses, so no annotations are needed. The
// declaration is enough.
import (
"fmt"
"os"
)
type J int
func (*J) method() {}
const globalConst = 0
var globalVar int //@ ir(globalVar,"&Global")
func globalFunc() {}
type I interface {
interfaceMethod()
}
type S struct {
x int //@ ir(x,"nil")
}
func main() {
print(globalVar) //@ ir(globalVar,"Load")
globalVar = 1 //@ ir(globalVar,"Const")
var v0 int = 1 //@ ir(v0,"Const") // simple local value spec
if v0 > 0 { //@ ir(v0,"Const")
v0 = 2 //@ ir(v0,"Const")
}
print(v0) //@ ir(v0,"Phi")
// v1 is captured and thus implicitly address-taken.
var v1 int = 1 //@ ir(v1,"Const")
v1 = 2 //@ ir(v1,"Const")
fmt.Println(v1) //@ ir(v1,"Load") // load
f := func(param int) { //@ ir(f,"MakeClosure"), ir(param,"Parameter")
if y := 1; y > 0 { //@ ir(y,"Const")
print(v1, param) //@ ir(v1,"Load") /*load*/, ir(param,"Sigma")
}
param = 2 //@ ir(param,"Const")
println(param) //@ ir(param,"Const")
}
f(0) //@ ir(f,"MakeClosure")
var v2 int //@ ir(v2,"Const") // implicitly zero-initialized local value spec
print(v2) //@ ir(v2,"Const")
m := make(map[string]int) //@ ir(m,"MakeMap")
// Local value spec with multi-valued RHS:
var v3, v4 = m[""] //@ ir(v3,"Extract"), ir(v4,"Extract"), ir(m,"MakeMap")
print(v3) //@ ir(v3,"Extract")
print(v4) //@ ir(v4,"Extract")
v3++ //@ ir(v3,"BinOp") // assign with op
v3 += 2 //@ ir(v3,"BinOp") // assign with op
v5, v6 := false, "" //@ ir(v5,"Const"), ir(v6,"Const") // defining assignment
print(v5) //@ ir(v5,"Const")
print(v6) //@ ir(v6,"Const")
var v7 S //@ ir(v7,"&Alloc")
v7.x = 1 //@ ir(v7,"&Alloc"), ir(x,"&FieldAddr")
print(v7.x) //@ ir(v7,"&Alloc"), ir(x,"&FieldAddr")
var v8 [1]int //@ ir(v8,"&Alloc")
v8[0] = 0 //@ ir(v8,"&Alloc")
print(v8[:]) //@ ir(v8,"&Alloc")
_ = v8[0] //@ ir(v8,"&Alloc")
_ = v8[:][0] //@ ir(v8,"&Alloc")
v8ptr := &v8 //@ ir(v8ptr,"Alloc"), ir(v8,"&Alloc")
_ = v8ptr[0] //@ ir(v8ptr,"Alloc")
_ = *v8ptr //@ ir(v8ptr,"Alloc")
v8a := make([]int, 1) //@ ir(v8a,"Slice")
v8a[0] = 0 //@ ir(v8a,"Slice")
print(v8a[:]) //@ ir(v8a,"Slice")
v9 := S{} //@ ir(v9,"&Alloc")
v10 := &v9 //@ ir(v10,"Alloc"), ir(v9,"&Alloc")
_ = v10 //@ ir(v10,"Alloc")
var v11 *J = nil //@ ir(v11,"Const")
v11.method() //@ ir(v11,"Const")
var v12 J //@ ir(v12,"&Alloc")
v12.method() //@ ir(v12,"&Alloc") // implicitly address-taken
// NB, in the following, 'method' resolves to the *types.Func
// of (*J).method, so it doesn't help us locate the specific
// ir.Values here: a bound-method closure and a promotion
// wrapper.
_ = v11.method //@ ir(v11,"Const")
_ = (*struct{ J }).method //@ ir(J,"nil")
// These vars are not optimised away.
if false {
v13 := 0 //@ ir(v13,"Const")
println(v13) //@ ir(v13,"Const")
}
switch x := 1; x { //@ ir(x,"Const")
case v0: //@ ir(v0,"Phi")
}
for k, v := range m { //@ ir(k,"Extract"), ir(v,"Extract"), ir(m,"MakeMap")
_ = k //@ ir(k,"Extract")
v++ //@ ir(v,"BinOp")
}
if y := 0; y > 1 { //@ ir(y,"Const"), ir(y,"Const")
}
var i interface{} //@ ir(i,"Const") // nil interface
i = 1 //@ ir(i,"MakeInterface")
switch i := i.(type) { //@ ir(i,"MakeInterface"), ir(i,"MakeInterface")
case int:
println(i) //@ ir(i,"Extract")
}
ch := make(chan int) //@ ir(ch,"MakeChan")
select {
case x := <-ch: //@ ir(x,"Recv") /*receive*/, ir(ch,"MakeChan")
_ = x //@ ir(x,"Recv")
}
// .Op is an inter-package FieldVal-selection.
var err os.PathError //@ ir(err,"&Alloc")
_ = err.Op //@ ir(err,"&Alloc"), ir(Op,"&FieldAddr")
_ = &err.Op //@ ir(err,"&Alloc"), ir(Op,"&FieldAddr")
// Exercise corner-cases of lvalues vs rvalues.
// (Guessing IsAddr from the 'pointerness' won't cut it here.)
type N *N
var n N //@ ir(n,"Const")
n1 := n //@ ir(n1,"Const"), ir(n,"Const")
n2 := &n1 //@ ir(n2,"Alloc"), ir(n1,"&Alloc")
n3 := *n2 //@ ir(n3,"Load"), ir(n2,"Alloc")
n4 := **n3 //@ ir(n4,"Load"), ir(n3,"Load")
_ = n4 //@ ir(n4,"Load")
}
go-tools-2021.1.2/go/ir/testdata/structconv.go 0000664 0000000 0000000 00000001103 14143223131 0021060 0 ustar 00root root 0000000 0000000 //+build ignore
// This file is the input to TestValueForExprStructConv in identical_test.go,
// which uses the same framework as TestValueForExpr does in source_test.go.
//
// In Go 1.8, struct conversions are permitted even when the struct types have
// different tags. This wasn't permitted in earlier versions of Go, so this file
// exists separately from valueforexpr.go to just test this behavior in Go 1.8
// and later.
package main
type t1 struct {
x int
}
type t2 struct {
x int `tag`
}
func main() {
var tv1 t1
var tv2 t2 = /*@ChangeType*/ (t2(tv1))
_ = tv2
}
go-tools-2021.1.2/go/ir/testdata/valueforexpr.go 0000664 0000000 0000000 00000006654 14143223131 0021410 0 ustar 00root root 0000000 0000000 //+build ignore
package main
// This file is the input to TestValueForExpr in source_test.go, which
// ensures that each expression e immediately following a /*@kind*/(x)
// annotation, when passed to Function.ValueForExpr(e), returns a
// non-nil Value of the same type as e and of kind 'kind'.
func f(spilled, unspilled int) {
_ = /*@Load*/ (spilled)
_ = /*@Parameter*/ (unspilled)
_ = /*@nil*/ (1 + 2) // (constant)
i := 0
f := func() (int, int) { return 0, 0 }
(print( /*@BinOp*/ (i + 1)))
_, _ = /*@Call*/ (f())
ch := /*@MakeChan*/ (make(chan int))
/*@Recv*/ (<-ch)
x := /*@Recv*/ (<-ch)
_ = x
select {
case /*@Extract*/ (<-ch):
case x := /*@Extract*/ (<-ch):
_ = x
}
defer /*@Function*/ (func() {
})()
go /*@Function*/ (func() {
})()
y := 0
if true && /*@BinOp*/ (bool(y > 0)) {
y = 1
}
_ = /*@Phi*/ (y)
map1 := /*@MakeMap*/ (make(map[string]string))
_ = map1
_ = /*@Slice*/ (make([]int, 0))
_ = /*@MakeClosure*/ (func() { print(spilled) })
sl := []int{}
_ = /*@Slice*/ (sl[:0])
_ = /*@Alloc*/ (new(int))
tmp := /*@Alloc*/ (new(int))
_ = tmp
var iface interface{}
_ = /*@TypeAssert*/ (iface.(int))
_ = /*@Load*/ (sl[0])
_ = /*@IndexAddr*/ (&sl[0])
_ = /*@Index*/ ([2]int{}[0])
var p *int
_ = /*@Load*/ (*p)
_ = /*@Load*/ (global)
/*@Load*/ (global)[""] = ""
/*@Global*/ (global) = map[string]string{}
var local t
/*UnOp*/ (local.x) = 1
// Exercise corner-cases of lvalues vs rvalues.
type N *N
var n N
/*@Load*/ (n) = /*@Load*/ (n)
/*@ChangeType*/ (n) = /*@Alloc*/ (&n)
/*@Load*/ (n) = /*@Load*/ (*n)
/*@Load*/ (n) = /*@Load*/ (**n)
}
func complit() {
// Composite literals.
// We get different results for
// - composite literal as value (e.g. operand to print)
// - composite literal initializer for addressable value
// - composite literal value assigned to blank var
// 1. Slices
print( /*@Slice*/ ([]int{}))
print( /*@Alloc*/ (&[]int{}))
print(& /*@Slice*/ ([]int{}))
sl1 := /*@Slice*/ ([]int{})
sl2 := /*@Alloc*/ (&[]int{})
sl3 := & /*@Slice*/ ([]int{})
_, _, _ = sl1, sl2, sl3
_ = /*@Slice*/ ([]int{})
_ = /*@Alloc*/ (& /*@Slice*/ ([]int{}))
_ = & /*@Slice*/ ([]int{})
// 2. Arrays
print( /*@Load*/ ([1]int{}))
print( /*@Alloc*/ (&[1]int{}))
print(& /*@Alloc*/ ([1]int{}))
arr1 := /*@Alloc*/ ([1]int{})
arr2 := /*@Alloc*/ (&[1]int{})
arr3 := & /*@Alloc*/ ([1]int{})
_, _, _ = arr1, arr2, arr3
_ = /*@Load*/ ([1]int{})
_ = /*@Alloc*/ (& /*@Alloc*/ ([1]int{}))
_ = & /*@Alloc*/ ([1]int{})
// 3. Maps
type M map[int]int
print( /*@MakeMap*/ (M{}))
print( /*@Alloc*/ (&M{}))
print(& /*@MakeMap*/ (M{}))
m1 := /*@MakeMap*/ (M{})
m2 := /*@Alloc*/ (&M{})
m3 := & /*@MakeMap*/ (M{})
_, _, _ = m1, m2, m3
_ = /*@MakeMap*/ (M{})
_ = /*@Alloc*/ (& /*@MakeMap*/ (M{}))
_ = & /*@MakeMap*/ (M{})
// 4. Structs
print( /*@Load*/ (struct{}{}))
print( /*@Alloc*/ (&struct{}{}))
print(& /*@Alloc*/ (struct{}{}))
s1 := /*@Alloc*/ (struct{}{})
s2 := /*@Alloc*/ (&struct{}{})
s3 := & /*@Alloc*/ (struct{}{})
_, _, _ = s1, s2, s3
_ = /*@Load*/ (struct{}{})
_ = /*@Alloc*/ (& /*@Alloc*/ (struct{}{}))
_ = & /*@Alloc*/ (struct{}{})
}
type t struct{ x int }
// Ensure we can locate methods of named types.
func (t) f(param int) {
_ = /*@Parameter*/ (param)
}
// Ensure we can locate init functions.
func init() {
m := /*@MakeMap*/ (make(map[string]string))
_ = m
}
// Ensure we can locate variables in initializer expressions.
var global = /*@MakeMap*/ (make(map[string]string))
go-tools-2021.1.2/go/ir/util.go 0000664 0000000 0000000 00000004501 14143223131 0016017 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 a number of miscellaneous utility functions.
import (
"fmt"
"go/ast"
"go/token"
"go/types"
"io"
"os"
"honnef.co/go/tools/go/ast/astutil"
)
//// AST utilities
func unparen(e ast.Expr) ast.Expr { return astutil.Unparen(e) }
// isBlankIdent returns true iff e is an Ident with name "_".
// They have no associated types.Object, and thus no type.
//
func isBlankIdent(e ast.Expr) bool {
id, ok := e.(*ast.Ident)
return ok && id.Name == "_"
}
//// Type utilities. Some of these belong in go/types.
// isPointer returns true for types whose underlying type is a pointer.
func isPointer(typ types.Type) bool {
_, ok := typ.Underlying().(*types.Pointer)
return ok
}
func isInterface(T types.Type) bool { return types.IsInterface(T) }
// deref returns a pointer's element type; otherwise it returns typ.
func deref(typ types.Type) types.Type {
if p, ok := typ.Underlying().(*types.Pointer); ok {
return p.Elem()
}
return typ
}
// recvType returns the receiver type of method obj.
func recvType(obj *types.Func) types.Type {
return obj.Type().(*types.Signature).Recv().Type()
}
// logStack prints the formatted "start" message to stderr and
// returns a closure that prints the corresponding "end" message.
// Call using 'defer logStack(...)()' to show builder stack on panic.
// Don't forget trailing parens!
//
func logStack(format string, args ...interface{}) func() {
msg := fmt.Sprintf(format, args...)
io.WriteString(os.Stderr, msg)
io.WriteString(os.Stderr, "\n")
return func() {
io.WriteString(os.Stderr, msg)
io.WriteString(os.Stderr, " end\n")
}
}
// newVar creates a 'var' for use in a types.Tuple.
func newVar(name string, typ types.Type) *types.Var {
return types.NewParam(token.NoPos, nil, name, typ)
}
// anonVar creates an anonymous 'var' for use in a types.Tuple.
func anonVar(typ types.Type) *types.Var {
return newVar("", typ)
}
var lenResults = types.NewTuple(anonVar(tInt))
// makeLen returns the len builtin specialized to type func(T)int.
func makeLen(T types.Type) *Builtin {
lenParams := types.NewTuple(anonVar(T))
return &Builtin{
name: "len",
sig: types.NewSignature(nil, lenParams, lenResults, false),
}
}
go-tools-2021.1.2/go/ir/wrappers.go 0000664 0000000 0000000 00000020173 14143223131 0016710 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 synthesis of Functions that delegate to declared
// methods; they come in three kinds:
//
// (1) wrappers: methods that wrap declared methods, performing
// implicit pointer indirections and embedded field selections.
//
// (2) thunks: funcs that wrap declared methods. Like wrappers,
// thunks perform indirections and field selections. The thunk's
// first parameter is used as the receiver for the method call.
//
// (3) bounds: funcs that wrap declared methods. The bound's sole
// free variable, supplied by a closure, is used as the receiver
// for the method call. No indirections or field selections are
// performed since they can be done before the call.
import (
"fmt"
"go/types"
)
// -- wrappers -----------------------------------------------------------
// makeWrapper returns a synthetic method that delegates to the
// declared method denoted by meth.Obj(), first performing any
// necessary pointer indirections or field selections implied by meth.
//
// The resulting method's receiver type is meth.Recv().
//
// This function is versatile but quite subtle! Consider the
// following axes of variation when making changes:
// - optional receiver indirection
// - optional implicit field selections
// - meth.Obj() may denote a concrete or an interface method
// - the result may be a thunk or a wrapper.
//
// EXCLUSIVE_LOCKS_REQUIRED(prog.methodsMu)
//
func makeWrapper(prog *Program, sel *types.Selection) *Function {
obj := sel.Obj().(*types.Func) // the declared function
sig := sel.Type().(*types.Signature) // type of this wrapper
var recv *types.Var // wrapper's receiver or thunk's params[0]
name := obj.Name()
var description Synthetic
var start int // first regular param
if sel.Kind() == types.MethodExpr {
name += "$thunk"
description = SyntheticThunk
recv = sig.Params().At(0)
start = 1
} else {
description = SyntheticWrapper
recv = sig.Recv()
}
if prog.mode&LogSource != 0 {
defer logStack("make %s to (%s)", description, recv.Type())()
}
fn := &Function{
name: name,
method: sel,
object: obj,
Signature: sig,
Synthetic: description,
Prog: prog,
functionBody: new(functionBody),
}
fn.initHTML(prog.PrintFunc)
fn.startBody()
fn.addSpilledParam(recv, nil)
createParams(fn, start)
indices := sel.Index()
var v Value = fn.Locals[0] // spilled receiver
if isPointer(sel.Recv()) {
v = emitLoad(fn, v, nil)
// For simple indirection wrappers, perform an informative nil-check:
// "value method (T).f called using nil *T pointer"
if len(indices) == 1 && !isPointer(recvType(obj)) {
var c Call
c.Call.Value = &Builtin{
name: "ir:wrapnilchk",
sig: types.NewSignature(nil,
types.NewTuple(anonVar(sel.Recv()), anonVar(tString), anonVar(tString)),
types.NewTuple(anonVar(sel.Recv())), false),
}
c.Call.Args = []Value{
v,
emitConst(fn, stringConst(deref(sel.Recv()).String())),
emitConst(fn, stringConst(sel.Obj().Name())),
}
c.setType(v.Type())
v = fn.emit(&c, nil)
}
}
// Invariant: v is a pointer, either
// value of *A receiver param, or
// address of A spilled receiver.
// We use pointer arithmetic (FieldAddr possibly followed by
// Load) in preference to value extraction (Field possibly
// preceded by Load).
v = emitImplicitSelections(fn, v, indices[:len(indices)-1], nil)
// Invariant: v is a pointer, either
// value of implicit *C field, or
// address of implicit C field.
var c Call
if r := recvType(obj); !isInterface(r) { // concrete method
if !isPointer(r) {
v = emitLoad(fn, v, nil)
}
c.Call.Value = prog.declaredFunc(obj)
c.Call.Args = append(c.Call.Args, v)
} else {
c.Call.Method = obj
c.Call.Value = emitLoad(fn, v, nil)
}
for _, arg := range fn.Params[1:] {
c.Call.Args = append(c.Call.Args, arg)
}
emitTailCall(fn, &c, nil)
fn.finishBody()
return fn
}
// createParams creates parameters for wrapper method fn based on its
// Signature.Params, which do not include the receiver.
// start is the index of the first regular parameter to use.
//
func createParams(fn *Function, start int) {
tparams := fn.Signature.Params()
for i, n := start, tparams.Len(); i < n; i++ {
fn.addParamObj(tparams.At(i), nil)
}
}
// -- bounds -----------------------------------------------------------
// makeBound returns a bound method wrapper (or "bound"), a synthetic
// function that delegates to a concrete or interface method denoted
// by obj. The resulting function has no receiver, but has one free
// variable which will be used as the method's receiver in the
// tail-call.
//
// Use MakeClosure with such a wrapper to construct a bound method
// closure. e.g.:
//
// type T int or: type T interface { meth() }
// func (t T) meth()
// var t T
// f := t.meth
// f() // calls t.meth()
//
// f is a closure of a synthetic wrapper defined as if by:
//
// f := func() { return t.meth() }
//
// Unlike makeWrapper, makeBound need perform no indirection or field
// selections because that can be done before the closure is
// constructed.
//
// EXCLUSIVE_LOCKS_ACQUIRED(meth.Prog.methodsMu)
//
func makeBound(prog *Program, obj *types.Func) *Function {
prog.methodsMu.Lock()
defer prog.methodsMu.Unlock()
fn, ok := prog.bounds[obj]
if !ok {
if prog.mode&LogSource != 0 {
defer logStack("%s", SyntheticBound)()
}
fn = &Function{
name: obj.Name() + "$bound",
object: obj,
Signature: changeRecv(obj.Type().(*types.Signature), nil), // drop receiver
Synthetic: SyntheticBound,
Prog: prog,
functionBody: new(functionBody),
}
fn.initHTML(prog.PrintFunc)
fv := &FreeVar{name: "recv", typ: recvType(obj), parent: fn}
fn.FreeVars = []*FreeVar{fv}
fn.startBody()
createParams(fn, 0)
var c Call
if !isInterface(recvType(obj)) { // concrete
c.Call.Value = prog.declaredFunc(obj)
c.Call.Args = []Value{fv}
} else {
c.Call.Value = fv
c.Call.Method = obj
}
for _, arg := range fn.Params {
c.Call.Args = append(c.Call.Args, arg)
}
emitTailCall(fn, &c, nil)
fn.finishBody()
prog.bounds[obj] = fn
}
return fn
}
// -- thunks -----------------------------------------------------------
// makeThunk returns a thunk, a synthetic function that delegates to a
// concrete or interface method denoted by sel.Obj(). The resulting
// function has no receiver, but has an additional (first) regular
// parameter.
//
// Precondition: sel.Kind() == types.MethodExpr.
//
// type T int or: type T interface { meth() }
// func (t T) meth()
// f := T.meth
// var t T
// f(t) // calls t.meth()
//
// f is a synthetic wrapper defined as if by:
//
// f := func(t T) { return t.meth() }
//
// TODO(adonovan): opt: currently the stub is created even when used
// directly in a function call: C.f(i, 0). This is less efficient
// than inlining the stub.
//
// EXCLUSIVE_LOCKS_ACQUIRED(meth.Prog.methodsMu)
//
func makeThunk(prog *Program, sel *types.Selection) *Function {
if sel.Kind() != types.MethodExpr {
panic(sel)
}
key := selectionKey{
kind: sel.Kind(),
recv: sel.Recv(),
obj: sel.Obj(),
index: fmt.Sprint(sel.Index()),
indirect: sel.Indirect(),
}
prog.methodsMu.Lock()
defer prog.methodsMu.Unlock()
// Canonicalize key.recv to avoid constructing duplicate thunks.
canonRecv, ok := prog.canon.At(key.recv).(types.Type)
if !ok {
canonRecv = key.recv
prog.canon.Set(key.recv, canonRecv)
}
key.recv = canonRecv
fn, ok := prog.thunks[key]
if !ok {
fn = makeWrapper(prog, sel)
if fn.Signature.Recv() != nil {
panic(fn) // unexpected receiver
}
prog.thunks[key] = fn
}
return fn
}
func changeRecv(s *types.Signature, recv *types.Var) *types.Signature {
return types.NewSignature(recv, s.Params(), s.Results(), s.Variadic())
}
// selectionKey is like types.Selection but a usable map key.
type selectionKey struct {
kind types.SelectionKind
recv types.Type // canonicalized via Program.canon
obj types.Object
index string
indirect bool
}
go-tools-2021.1.2/go/ir/write.go 0000664 0000000 0000000 00000000147 14143223131 0016176 0 ustar 00root root 0000000 0000000 package ir
func NewJump(parent *BasicBlock) *Jump {
return &Jump{anInstruction{block: parent}, ""}
}
go-tools-2021.1.2/go/loader/ 0000775 0000000 0000000 00000000000 14143223131 0015347 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/go/loader/buildid.go 0000664 0000000 0000000 00000013507 14143223131 0017320 0 ustar 00root root 0000000 0000000 // 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 loader
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
}
go-tools-2021.1.2/go/loader/hash.go 0000664 0000000 0000000 00000003731 14143223131 0016625 0 ustar 00root root 0000000 0000000 package loader
import (
"fmt"
"runtime"
"sort"
"strings"
"honnef.co/go/tools/internal/cache"
)
// computeHash computes a package's hash. The hash is based on all Go
// files that make up the package, as well as the hashes of imported
// packages.
func computeHash(c *cache.Cache, pkg *PackageSpec) (cache.ActionID, error) {
key := c.NewHash("package " + pkg.PkgPath)
fmt.Fprintf(key, "goos %s goarch %s\n", runtime.GOOS, runtime.GOARCH)
fmt.Fprintf(key, "import %q\n", pkg.PkgPath)
// Compute the hashes of all files making up the package. As an
// optimization, we use the build ID that Go already computed for
// us, because it is virtually identical to hashed all
// CompiledGoFiles.
success := false
if pkg.ExportFile != "" {
id, err := getBuildid(pkg.ExportFile)
if err == nil {
if idx := strings.IndexRune(id, '/'); idx > -1 {
fmt.Fprintf(key, "files %s\n", id[:idx])
success = true
}
}
}
if !success {
for _, f := range pkg.CompiledGoFiles {
h, err := cache.FileHash(f)
if err != nil {
return cache.ActionID{}, err
}
fmt.Fprintf(key, "file %s %x\n", f, h)
}
}
imps := make([]*PackageSpec, 0, len(pkg.Imports))
for _, v := range pkg.Imports {
imps = append(imps, v)
}
sort.Slice(imps, func(i, j int) bool {
return imps[i].PkgPath < imps[j].PkgPath
})
for _, dep := range imps {
if dep.ExportFile == "" {
fmt.Fprintf(key, "import %s \n", dep.PkgPath)
} else {
id, err := getBuildid(dep.ExportFile)
if err == nil {
fmt.Fprintf(key, "import %s %s\n", dep.PkgPath, id)
} else {
fh, err := cache.FileHash(dep.ExportFile)
if err != nil {
return cache.ActionID{}, err
}
fmt.Fprintf(key, "import %s %x\n", dep.PkgPath, fh)
}
}
}
return key.Sum(), nil
}
var buildidCache = map[string]string{}
func getBuildid(f string) (string, error) {
if h, ok := buildidCache[f]; ok {
return h, nil
}
h, err := ReadFile(f)
if err != nil {
return "", err
}
buildidCache[f] = h
return h, nil
}
go-tools-2021.1.2/go/loader/loader.go 0000664 0000000 0000000 00000021746 14143223131 0017156 0 ustar 00root root 0000000 0000000 package loader
import (
"errors"
"fmt"
"go/ast"
"go/parser"
"go/scanner"
"go/token"
"go/types"
"os"
"time"
"honnef.co/go/tools/config"
"honnef.co/go/tools/internal/cache"
"honnef.co/go/tools/internal/go/gcimporter"
"golang.org/x/tools/go/packages"
)
const MaxFileSize = 50 * 1024 * 1024 // 50 MB
var errMaxFileSize = errors.New("file exceeds max file size")
type PackageSpec struct {
ID string
Name string
PkgPath string
// Errors that occurred while building the import graph. These will
// primarily be parse errors or failure to resolve imports, but
// may also be other errors.
Errors []packages.Error
GoFiles []string
CompiledGoFiles []string
OtherFiles []string
ExportFile string
Imports map[string]*PackageSpec
TypesSizes types.Sizes
Hash cache.ActionID
Module *packages.Module
Config config.Config
}
func (spec *PackageSpec) String() string {
return spec.ID
}
type Package struct {
*PackageSpec
// Errors that occurred while loading the package. These will
// primarily be parse or type errors, but may also be lower-level
// failures such as file-system ones.
Errors []packages.Error
Types *types.Package
Fset *token.FileSet
Syntax []*ast.File
TypesInfo *types.Info
}
// Graph resolves patterns and returns packages with all the
// information required to later load type information, and optionally
// syntax trees.
//
// The provided config can set any setting with the exception of Mode.
func Graph(c *cache.Cache, cfg *packages.Config, patterns ...string) ([]*PackageSpec, error) {
var dcfg packages.Config
if cfg != nil {
dcfg = *cfg
}
dcfg.Mode = packages.NeedName |
packages.NeedImports |
packages.NeedDeps |
packages.NeedExportsFile |
packages.NeedFiles |
packages.NeedCompiledGoFiles |
packages.NeedTypesSizes |
packages.NeedModule
pkgs, err := packages.Load(&dcfg, patterns...)
if err != nil {
return nil, err
}
m := map[*packages.Package]*PackageSpec{}
packages.Visit(pkgs, nil, func(pkg *packages.Package) {
spec := &PackageSpec{
ID: pkg.ID,
Name: pkg.Name,
PkgPath: pkg.PkgPath,
Errors: pkg.Errors,
GoFiles: pkg.GoFiles,
CompiledGoFiles: pkg.CompiledGoFiles,
OtherFiles: pkg.OtherFiles,
ExportFile: pkg.ExportFile,
Imports: map[string]*PackageSpec{},
TypesSizes: pkg.TypesSizes,
Module: pkg.Module,
}
for path, imp := range pkg.Imports {
spec.Imports[path] = m[imp]
}
if cdir := config.Dir(pkg.GoFiles); cdir != "" {
cfg, err := config.Load(cdir)
if err != nil {
spec.Errors = append(spec.Errors, convertError(err)...)
}
spec.Config = cfg
} else {
spec.Config = config.DefaultConfig
}
spec.Hash, err = computeHash(c, spec)
if err != nil {
spec.Errors = append(spec.Errors, convertError(err)...)
}
m[pkg] = spec
})
out := make([]*PackageSpec, 0, len(pkgs))
for _, pkg := range pkgs {
if len(pkg.CompiledGoFiles) == 0 && len(pkg.Errors) == 0 && pkg.PkgPath != "unsafe" {
// If a package consists only of test files, then
// go/packages incorrectly(?) returns an empty package for
// the non-test variant. Get rid of those packages. See
// #646.
//
// Do not, however, skip packages that have errors. Those,
// too, may have no files, but we want to print the
// errors.
continue
}
out = append(out, m[pkg])
}
return out, nil
}
type program struct {
fset *token.FileSet
packages map[string]*types.Package
}
type Stats struct {
Source time.Duration
Export map[*PackageSpec]time.Duration
}
// Load loads the package described in spec. Imports will be loaded
// from export data, while the package itself will be loaded from
// source.
//
// An error will only be returned for system failures, such as failure
// to read export data from disk. Syntax and type errors, among
// others, will only populate the returned package's Errors field.
func Load(spec *PackageSpec) (*Package, Stats, error) {
prog := &program{
fset: token.NewFileSet(),
packages: map[string]*types.Package{},
}
stats := Stats{
Export: map[*PackageSpec]time.Duration{},
}
var b []byte
for _, imp := range spec.Imports {
if imp.PkgPath == "unsafe" {
continue
}
t := time.Now()
var err error
_, b, err = prog.loadFromExport(imp, b)
stats.Export[imp] = time.Since(t)
if err != nil {
return nil, stats, err
}
}
t := time.Now()
pkg, err := prog.loadFromSource(spec)
if err == errMaxFileSize {
pkg, _, err = prog.loadFromExport(spec, b)
}
stats.Source = time.Since(t)
return pkg, stats, err
}
// loadFromExport loads a package from export data.
func (prog *program) loadFromExport(spec *PackageSpec, b []byte) (*Package, []byte, error) {
// log.Printf("Loading package %s from export", spec)
if spec.ExportFile == "" {
return nil, b, fmt.Errorf("no export data for %q", spec.ID)
}
f, err := os.Open(spec.ExportFile)
if err != nil {
return nil, b, err
}
defer f.Close()
b, err = gcimporter.GetExportData(f, b)
if err != nil {
return nil, b, err
}
_, tpkg, err := gcimporter.IImportData(prog.fset, prog.packages, b[1:], spec.PkgPath)
if err != nil {
return nil, b, err
}
pkg := &Package{
PackageSpec: spec,
Types: tpkg,
Fset: prog.fset,
}
// runtime.SetFinalizer(pkg, func(pkg *Package) {
// log.Println("Unloading package", pkg.PkgPath)
// })
return pkg, b, nil
}
// loadFromSource loads a package from source. All of its dependencies
// must have been loaded already.
func (prog *program) loadFromSource(spec *PackageSpec) (*Package, error) {
if len(spec.Errors) > 0 {
panic("LoadFromSource called on package with errors")
}
pkg := &Package{
PackageSpec: spec,
Types: types.NewPackage(spec.PkgPath, spec.Name),
Syntax: make([]*ast.File, len(spec.CompiledGoFiles)),
Fset: prog.fset,
TypesInfo: &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),
},
}
// runtime.SetFinalizer(pkg, func(pkg *Package) {
// log.Println("Unloading package", pkg.PkgPath)
// })
// OPT(dh): many packages have few files, much fewer than there
// are CPU cores. Additionally, parsing each individual file is
// very fast. A naive parallel implementation of this loop won't
// be faster, and tends to be slower due to extra scheduling,
// bookkeeping and potentially false sharing of cache lines.
for i, file := range spec.CompiledGoFiles {
f, err := os.Open(file)
if err != nil {
return nil, err
}
fi, err := f.Stat()
if err != nil {
return nil, err
}
if fi.Size() >= MaxFileSize {
return nil, errMaxFileSize
}
af, err := parser.ParseFile(prog.fset, file, f, parser.ParseComments)
f.Close()
if err != nil {
pkg.Errors = append(pkg.Errors, convertError(err)...)
return pkg, nil
}
pkg.Syntax[i] = af
}
importer := func(path string) (*types.Package, error) {
if path == "unsafe" {
return types.Unsafe, nil
}
if path == "C" {
// go/packages doesn't tell us that cgo preprocessing
// failed. When we subsequently try to parse the package,
// we'll encounter the raw C import.
return nil, errors.New("cgo preprocessing failed")
}
ispecpkg := spec.Imports[path]
if ispecpkg == nil {
return nil, fmt.Errorf("trying to import %q in the context of %q returned nil PackageSpec", path, spec)
}
ipkg := prog.packages[ispecpkg.PkgPath]
if ipkg == nil {
return nil, fmt.Errorf("trying to import %q (%q) in the context of %q returned nil PackageSpec", ispecpkg.PkgPath, path, spec)
}
return ipkg, nil
}
tc := &types.Config{
Importer: importerFunc(importer),
Error: func(err error) {
pkg.Errors = append(pkg.Errors, convertError(err)...)
},
}
types.NewChecker(tc, pkg.Fset, pkg.Types, pkg.TypesInfo).Files(pkg.Syntax)
return pkg, nil
}
func convertError(err error) []packages.Error {
var errs []packages.Error
// taken from go/packages
switch err := err.(type) {
case packages.Error:
// from driver
errs = append(errs, err)
case *os.PathError:
// from parser
errs = append(errs, packages.Error{
Pos: err.Path + ":1",
Msg: err.Err.Error(),
Kind: packages.ParseError,
})
case scanner.ErrorList:
// from parser
for _, err := range err {
errs = append(errs, packages.Error{
Pos: err.Pos.String(),
Msg: err.Msg,
Kind: packages.ParseError,
})
}
case types.Error:
// from type checker
errs = append(errs, packages.Error{
Pos: err.Fset.Position(err.Pos).String(),
Msg: err.Msg,
Kind: packages.TypeError,
})
default:
errs = append(errs, packages.Error{
Pos: "-",
Msg: err.Error(),
Kind: packages.UnknownError,
})
}
return errs
}
type importerFunc func(path string) (*types.Package, error)
func (f importerFunc) Import(path string) (*types.Package, error) { return f(path) }
go-tools-2021.1.2/go/loader/note.go 0000664 0000000 0000000 00000013420 14143223131 0016643 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 loader
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)
}
go-tools-2021.1.2/go/types/ 0000775 0000000 0000000 00000000000 14143223131 0015245 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/go/types/typeutil/ 0000775 0000000 0000000 00000000000 14143223131 0017124 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/go/types/typeutil/upstream.go 0000664 0000000 0000000 00000000764 14143223131 0021322 0 ustar 00root root 0000000 0000000 package typeutil
import (
"go/ast"
"go/types"
_ "unsafe"
"golang.org/x/tools/go/types/typeutil"
)
type MethodSetCache = typeutil.MethodSetCache
type Map = typeutil.Map
type Hasher = typeutil.Hasher
func Callee(info *types.Info, call *ast.CallExpr) types.Object {
return typeutil.Callee(info, call)
}
func IntuitiveMethodSet(T types.Type, msets *MethodSetCache) []*types.Selection {
return typeutil.IntuitiveMethodSet(T, msets)
}
func MakeHasher() Hasher {
return typeutil.MakeHasher()
}
go-tools-2021.1.2/go/types/typeutil/util.go 0000664 0000000 0000000 00000005737 14143223131 0020444 0 ustar 00root root 0000000 0000000 package typeutil
import (
"bytes"
"go/types"
"sync"
)
var bufferPool = &sync.Pool{
New: func() interface{} {
buf := bytes.NewBuffer(nil)
buf.Grow(64)
return buf
},
}
func FuncName(f *types.Func) string {
buf := bufferPool.Get().(*bytes.Buffer)
buf.Reset()
if f.Type() != nil {
sig := f.Type().(*types.Signature)
if recv := sig.Recv(); recv != nil {
buf.WriteByte('(')
if _, ok := recv.Type().(*types.Interface); ok {
// gcimporter creates abstract methods of
// named interfaces using the interface type
// (not the named type) as the receiver.
// Don't print it in full.
buf.WriteString("interface")
} else {
types.WriteType(buf, recv.Type(), nil)
}
buf.WriteByte(')')
buf.WriteByte('.')
} else if f.Pkg() != nil {
writePackage(buf, f.Pkg())
}
}
buf.WriteString(f.Name())
s := buf.String()
bufferPool.Put(buf)
return s
}
func writePackage(buf *bytes.Buffer, pkg *types.Package) {
if pkg == nil {
return
}
s := pkg.Path()
if s != "" {
buf.WriteString(s)
buf.WriteByte('.')
}
}
// Dereference returns a pointer's element type; otherwise it returns
// T.
func Dereference(T types.Type) types.Type {
if p, ok := T.Underlying().(*types.Pointer); ok {
return p.Elem()
}
return T
}
// DereferenceR returns a pointer's element type; otherwise it returns
// T. If the element type is itself a pointer, DereferenceR will be
// applied recursively.
func DereferenceR(T types.Type) types.Type {
if p, ok := T.Underlying().(*types.Pointer); ok {
return DereferenceR(p.Elem())
}
return T
}
func IsObject(obj types.Object, name string) bool {
var path string
if pkg := obj.Pkg(); pkg != nil {
path = pkg.Path() + "."
}
return path+obj.Name() == name
}
// OPT(dh): IsType is kind of expensive; should we really use it?
func IsType(T types.Type, name string) bool { return types.TypeString(T, nil) == name }
func IsPointerLike(T types.Type) bool {
switch T := T.Underlying().(type) {
case *types.Interface, *types.Chan, *types.Map, *types.Signature, *types.Pointer, *types.Slice:
return true
case *types.Basic:
return T.Kind() == types.UnsafePointer
}
return false
}
type Field struct {
Var *types.Var
Tag string
Path []int
}
// FlattenFields recursively flattens T and embedded structs,
// returning a list of fields. If multiple fields with the same name
// exist, all will be returned.
func FlattenFields(T *types.Struct) []Field {
return flattenFields(T, nil, nil)
}
func flattenFields(T *types.Struct, path []int, seen map[types.Type]bool) []Field {
if seen == nil {
seen = map[types.Type]bool{}
}
if seen[T] {
return nil
}
seen[T] = true
var out []Field
for i := 0; i < T.NumFields(); i++ {
field := T.Field(i)
tag := T.Tag(i)
np := append(path[:len(path):len(path)], i)
if field.Anonymous() {
if s, ok := Dereference(field.Type()).Underlying().(*types.Struct); ok {
out = append(out, flattenFields(s, np, seen)...)
}
} else {
out = append(out, Field{field, tag, np})
}
}
return out
}
go-tools-2021.1.2/images/ 0000775 0000000 0000000 00000000000 14143223131 0014741 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/images/logo.svg 0000664 0000000 0000000 00000360446 14143223131 0016437 0 ustar 00root root 0000000 0000000
go-tools-2021.1.2/images/screenshots/ 0000775 0000000 0000000 00000000000 14143223131 0017301 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/images/screenshots/struct.png 0000664 0000000 0000000 00000045063 14143223131 0021343 0 ustar 00root root 0000000 0000000 PNG
IHDR X Β Vhρ gAMA ± όa cHRM z& ϊ θ u0 κ` : pΊQ< άPLTEπππΆΆΆPPPΗΗΗΣΣΣΠΠΠιι騨¨fffsss°°°hhhiii ²²²ΘΘΘ΅΅΅&&&...)))³³³ ---***=== ξξξοοοβββζζζηηηκκκ ΡΡΡ333JJJ""";;;λλλαααεεε©©© BBBͺͺͺ ’’’^^^μμμ~~~>>>ΦΦΦFFFΜΜΜ
΄΄΄999nnnMMMAAAΕΕΕ:::///111zzzΎΎΎ δδδΖΖΖkkkZZZ¬¬¬SSSTTT444₯₯₯CCC+++
ΑΑΑ$$$§§§'''cccOOO555WWW{{{θθθΨΨΨΤΤΤaaaxxx!!!@@@KKK<<<(((yyyΈΈΈ}}}QQQ γγγvvvΟΟΟwww¦¦¦222000···XXX### ΰΰΰLLL
DDDνννqqq«««ΌΌΌYYYΪΪΪήήή½½½RRRtttΔΔΔ777eeeΛΛΛ±±±HHHΞΞΞΒΒΒ]]]jjj‘‘‘€€€ΙΙΙ»»»```???ΉΉΉάάά£££___ΧΧΧέέέ―――ΊΊΊΓΓΓΐΐΐίίίΚΚΚ666%%%dddUUUVVVΩΩΩF΄rrrΥΥΥΫΫΫΝΝΝ,,,[[[888NNNbbbmmmlllgggGGGΏΏΏ|||\\\IIIooopppEEEuuu 0mΙ bKGD󬱾ξ pHYs
Χ
ΧB(x tIMEΰq1 FIDATxΪνέύCSυρ§X/η¦yΙDTTP¬©J
SKΡ°΄ς"-Αb¦
&iWοΌΘΌΧϊQ4MλEο.ΎΑχυ:Ϋΰp©O°|ά~8³ Ψέ³ { ΐΏU½ϊ
ͺ΅WΓ
½ΌΛΉ’Ρ}υο'ςi\ΊώΦ .ω&ε,5ΤozνB25k^zy ρ λ!ΡaέΫΚλaΡκΫ[·iΣΆ]{Ρ‘ΤςΤτΞ~uύAέRa»^ͺ ΛΏ«g.ΐ_·±v=JmΨSM{υv_
.Ύ* O]³P{|EίϋB± Ήχ£ΪΗ,ύEke Qθ ΞBtj€·°DΘγ=ΫΉΒς³vΣCΤ|e\)<Β"Ω¬ΛP’aΓ#EΰκLμΙ§’FμuύΝBνρΝF5Z|E-5
κK(ωB.(ςI’\ςε$6}lί$ηgksDRgKu―ρqυ?ωdψT»4P<υΥ?χ³6 )`kδηM·m}Ρw ήΉλ?κ9h Χ0ͺ£δsEO9Ώ[<^―ήΛKE/΄={χWaέ{|EΫαBD6ΞΡ.]}z$ D}^±
!ςεπΛd9Ή(,υ
q§hΟIγΓ
θνS&,ΪYdΫΏaέ 8θ;$FΊΞ±k‘]hΨmέBτEε_ΆΠΰOp―σλ¨ω °ι«bi]οόϋ ΧσιΊή Ίεw8Ίζ7rδPLO1sέβ£e9ϊ>}LρGτpLΜq’Ά»nοΞθ>υgΕλΈυm:I΄ηXek&©/ΫφΤό§tOι{JDΦO©ΒofffO―.±Μ+3iήΡM±ΣζM*g5―YδέςΤ<νcθνeυϋ΅¨ ςQϋ2 χ^y ϋpρ
3s*ΨΝ ³ΛXζωsΚ_-Y6Ύβο6ψΌMDΞΏ ιdWπ?ΑΥέέm³f\X
;xΡκγ3ιKΡOΏ¬έ*?’ΧCΛέ °
Ο_εΎ½ΖυυTΉaM-ηφζΜΤ]`¨`7ϋLo1&κ+±[»°»½©ΟSamΟ«ψ»uiΒζaΖεά Vαtͺε°> ϊΜTpϋ;x1YMG!Ϊ₯ζς.α\Σιόͺ³ΣCtΕwϊ hgPοT΅ΒW [ζZ$§Wr©ϋ3N§λ²KΥ₯ΝCςΙΑί©}0\Ψ’Λ_Δ;κΟΊψφυH‘Λ΄η:ΓΧ-»nH §Ζ[^5l]SΟ ωΥ §iQo]\*,ΗΓΦ_V3*¬κσ ϊμρυκγ ³kοϊ’O¦39©ςίΝqS`ώQΛauά"'ΉbΖνο _3Ήέ«κrώZΪj±X2νKΏ³ΆkIφ₯ςi@|τZaΝSΧZl‘>Iχθ7Τ8Ξd±Di·V"¬σΛF/K>J]/©γVμ΅λ#-7(ΰ9ϋΘ^ΦέξϋOtΣϋμ―Η‘
ͺOπ
Ks[&Nlέν~gήVΣYT2¬U[Oi·θ96\y:°±( ½βbΰδι }CNΎm―fίΥu5RΛaΕύWNBMn/¦ΖΔ|?oy.,z MΞ,9#'kCδp?[ λti ΊFΌ(―L-(|m[+Vδ0
z²[ 5n&7\m=α>^Μ7ΘS»χsΦ @R yΩDξφμ’s¬Ν+δGχ¦σλφ΅©6Ϋ\*¬ ω2Αο¦z²φ5ΏΣ Ί0W «γAςJώή½ζ±ΨO―}2η uέFΤrXΆ7Υ4ωώΫίΑαιι { ΦHν#½Nuay>'u:s\ϊώΦa©Gnάn―©|Έ3<ηXF΅‘Φώ5ΏmIκ3νϋΉNθ\ayοM±Τη Ώ9lT·Ψe¬«τ9Vσ]±(¬>&_Ru§ΒzAΞύxή½ή k³5Ϊg'Ύ1ΉΫ¨Z«΅λkΚνο v(μ³ )§Ό°ΜΙΛΣΣ;YRΗΛ°Όά¬yIMΣΎΌuX ΙΏBy
υψyΪ₯>ίY +ΪΤ>==ΙbϋΞ΅fΊ/jlΚ?wΘμΛ|~Ω`υι<ΧΣ§Η=·½ιΜLυ!Q|_2,Ώ¬cWuVΟzξ°¨Ο¬£ΕZX?ΙΉYCά+¦MάL)T νσΐάΊn£Fj9¬Ικζ`ΡφφwΠuς>@μ₯΅ημaΩkg2¬ ξ
Φ<¦ΧZX *K½μlNΤΖΊωυΔ€
uP<£έfkΝ/zi_Ό>iϋΦ ΦdΣΧ⨢磴LΧΞ2-κC}₯λF±Zx@=λω
+Τ[{΄°Τ+OXW΄Μv!W§'Φu5RΛa
υSTα+¬_ΔlϊΪ NόK
Σά>¬|ωJν΅λ1 8,uz΄O=S_ΟgϋΤ!^]·κWύύ(τςfΆ+,_[_uq―X‘_οΔ΅k7H[©QLσctoό:ON
©^gάW&¬ΑΪΫ5κΫΣλΊ©ε°ςlm3Vε΄τbΣΉπηΔ4’EΆ9Ήϋm%ΒdZ
.―6ΈΒΚ³¬aΩΟ:’οBήΖϊΡ'¦V ύ³Π £Υ;φυl³Ψ΄§α&κΎΦΏθώθ\Σ’NPτό΅°Ύ%ωΡΖΕA‘ο\«9Fmλγγ³Ο}?Ϊ‘π]Λ^Χ₯Χ/hΜ\]Xτυ³¨)Ζ2aΡΚΉ»ΜkFΩ²ΓΊώΙj9,zθI<~€
;xQQhi¬^£M±BνdΊHΞΆΕ#υmΞ’'Kί
ω «μΡυ¬gΞμe*{ύ Έr6:1Ξυ>ΗΌ*ΌrΎΥzXuλm‘>l9΅§ΡλϊΫζ
°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°ΒθsΩ=RςΥφι\!’ΣμBτj£ΏaA΅=ψύΓ§b kΞ°°1―FΡ]° ΪόΤδρξKΫ έu jζΓξ\―n1Β1XΏS_κ΅{’sFn9Βθ2]ΛiΤ#½ςίςΣ]° ϊ^yΑ3ύgέ5 ͺ―koKAρ₯ϋuW!,¨6ΗώΞΉΕΜICtΧ!,¨ΆGνύ|||-^ l(ΪκCXP]f‘I$κ+ΏjΏaΑ ` |όBΝo wΰF £ΰI1JΧΚ9Ϊόwςk2 viQLEλ=έ₯h>7&§βμr€’kυίXΩΞ&hY»w ψφ‘)IBύ_λΒΜs·ήβΝΜΜLγιΥ%ye&Ν;Ί)vΪΌJ %σSη-‘'γχίΤ.fέΎΟ―X<ΏG8*Ί½Ύ+
ΞΤuD ¨x_N³ηwπb² "RsyΙp.Ιιt~ΥΩι\ρ€ΡΞ 0ί©Ϊ‘M/φ¬9+D§λ vΒIΤΗ°ΘW]ΩπύNη&Χ=ΚW)Ηϊ{Ό~ζTΚ
3fμτμΘC"Wξtςύϊs4i΅ώ Qaν=¬φγοlΉ/δp:fϋN(zφkέXN>1αΉt/¨ε°4ΏRΣn;,Ώf[δσͺΊΏφ'¦Z,L»ΕΕο¬νZ})ΡvρQD;j
N£³η^‘οbΕ²\,·ΈͺΤ‘p‘x'~²u΄>°XΈξαΗ·εδΡψHRδ&νPx^ήΊ%Rέcα΄Άρξ &φΙ:νιφν΅σΦεVu<φ
―,?Έ@QβώΐΙ-£έk^{NNώ3MNΜωκϊ1―uΦαψδ΄{φFΊ°RcbΎ· rΚ ΛΌ<=½%uΌ ΛΛ΅ώ^1LN
βαςΓκ.ηdθΓJύετd7SΪ;^°d«WxiωιιΧ,c?t·έ$_@4)μ Ϋ· ¬Ω;χΒΪ%Τi^_-,υκοΉωξ άzΊμNζΞ6«λΗΌVΤvX‘7ZΤΧcΣΣΣ#.₯;o΅χb/ύ «ζ²Keo¬hΘ°άΏΆ±H{κ:. Κ―dXήBϋ=’ νWF\a]θ\_½Κθ΄C»ρ0Χz_-WΣλφνΕΜDa’iQXWΔBΉψ-,υΡAμΣ κe*=ξ΅ VΞΐ(mf}ΤώZΜ-ί.u
υM_ΫrECaη·aΒ
΅ΞΣ¦#υ\Ο’{ζyΙVΧΡ§΅γαΗ+υΟΤΈ΅mψSΊEΙΙ:]XΩΟΘ%o «»Pr·G4ΣτWκϊ1―΅ Φ³¦ο|$χ{E·u( q:ώ&lsrχΫJ5Ι΄€ ]^mp
gYOτν₯&ζcWoPεaύ½|cCχϋνί1A΄°pΦ«ΖmYYYώ4ΞqΊτoβZmΈν½ΤτQΛΧ’%'i_{]XτLDΏ¨ο Λά~ZΩΠrΉ ΥίΎ» σZQΛa]ΏΝκοΊt[aΙΥ -Υ»ESl¦ζ%Oήi¨QXΕdwXΥ§λ¬πBΣoY·kΣ_Τ(DΚ§ΝW
mΙ©γΝZXΪ>n!zxΊΌρnξW4ε0₯ήmt°» ·ΈVϊ°rώ ?ΐδ(5Ψ*L’Η.9χuΎw]?ζ΅’ΓͺθqΡeων ·ΉΤ’SVιf―«γγ€ΑΏμUΗuΗκΠΫ΄(Ά|εYbΞ5έhΞ²rξdσ8Χϋ΄ ζά± Η]ν 1ρΑUZόμ
―ΪyθDJμ'*ήv±O]»΅aέQQ§ΈτΉ£ζ7τ°ξ°θΛ5Ώ,°@Xΐa ,°@Xΐa ,°@Xΐa ,°@Xΐa ,°@Xΐa ,°@Xΐa ,°@Xΐa ,°@Xΐa ,°@Xΐa ,°@Xΐa ,°@Xΐa ,°@Xΐa ,°@Xΐa ,Τ@Γ~\° ΪΎ"υΧ97₯ηͺΜ¨Χ!,¨Ά‘_Ϋ6*βΌ»Ύεc±«Δu j¦q φe1Β;κΖ5ν Β;ΗΡξίVmΤfά9Ρσ?ά©Ν",Έ£NτΆ¨― ξ¬FβΈϊ°ΰΞj.φͺ/ ξ']Nx!n΄(Ο§Xκ³Ww Βj» .-#AΞυΚ@έu ͺ/ΕpΕ»χ (zp¨{ξBΧjίΘC1a<)ΖP{ά &ζ¨ώς 11 δ9|{[Ώ[όa@LAuξύΓDΗφάΖ]ͺΗ]iΤ2!lυ/εnΙβΑa·ήβΝΜΜLγιΥ%ye&Ν;Ί)vΪΌIΥΪyρIί&θύa¨pυ΅©υΤfΌGgϊΘ/w&tY -½^ΫVεl|<ϋrΡ|°X_Ι^΅Θ|»ό+ώΚ VρΫξ; ΈCλρb΅~ ,jω
wGν
{‘υ#DΏ?ώυΈ#wήr/Z}|&})ϊι΅[εGτZ`θ-7.ψΘg}« ΝΕΊΦζ»g>΅ΈΚH(?¬ηv³ρηΪ\¨x§f. Rώ5*¬ΌνoωξΦ ¦/Πζε;ͺω#ΉσκβχvαώΈciν-wπb²?τMQj.ο2Ξ%9Ξ―:;9DW|'©§hgPοT΅Β’AGt½MΞζ8S¦nqθλΑ{h:y‘r#ΌΘΰ₯p-:ς@΅η!ν^Μο΅εΟΦKJUΰ{ΘθςTΧΊ?:άιεψ½·IΡAΎ{ΈSέΪΒV+ςΜrwΊPSΙ ύϋΆϊ©8mσγK Λο§ϊkξTXOͺ%ΫGύDΞκg²{χ&έΊC\aΔχ€yουCϋz"ό6ΓςkΆ
hΓUu9-νOL΅X,v₯ίYΫ΅$ϋR’νβ£€wΤ
k^ml?ϋr6KL ²`μgέZΪ~φ5%ςύΠLνΙΩ$οφ"Φb9B»³W₯YΧQΧλΩΓΣCϊ+¨γΟΗυaέ8σRηξ΄K,~ΗΎH±XRΒθ±=Ζ<χήOi-'αcX‘
[Θ=·$Η
km<"Ϊσmφξ]*¬ω3§ώGΕBΗkγMΣΧDίJΛt ^-οIσ λύ_Ά\υjΌzΒΤοη-ΟΣ
EΘ 3-9£ τcςA±
Ι°NgΦλ!Ο4ΜΊ°Z€θιηNmJδ>NυkL .Ν!2δ"Δ΅ξCaXκ3fΪvi
Ν+β’λ 9%Β2ζζ€52 ωΈΣW=Βύ£χξ:σώ!ς<«Οε’s¬γΙKhsζΩ Jθό
ϋ»,Έ΄J
5F>© yΕaMI G;
+; ιΊU·θϊ³κκοΛ°Ϊ§§w»B^Zp¨Ήυ;¬g©Mο{Zο+¬ΙQT"¬Χε―)|YάΑ ΦauςiΜύϊoδ―r²"u‘vΑ ΦαeηΝ4*U΅ξΎΏδχQ*,2'μrζ7/λΑ/΅[Vaύ η>θ¬ϋ‘.p}υ]κ:(ZK>CάV_χ}Γ|λ Τ
}$ε9yyzz'Kκx{5ΪΏd]XδάwΛεΛΤΊΦWάΒζ&ω2~u3MΜπΌ >?Ίφ½ΞnΤΣγ~*Ϊ`ͺp#πEκΡΕ VΡ2=ύLgΡΤ΅m³³rβx\X^9ζ «OΗαήD€¦§§ΟmκZΥς2a5Ώj5Zμo9Eέ<SΏμ²aυ t¨°Θ) SΣK ϋέΖΊNή½τs¬Λ.½±v2\ ΓςΌβZσͺΦp9Ω€
΅Ξ Vς·ΪΊ^ξ°ό¬ςί}ΐΥ)ΗΥI+¬Χ΄5ΖΙΩ]ν|uaεͺ`¦^7ΒzAΞm
ώΫυΔ€
υ8€έFkΫλη΄/ΗΏaΰ
+ηΗεΖFm5χyoq2³δΔτ}ΕίwTxsωͺΧ8§8¬εκ9ςΦΪ
ΒzΪPΧAΥeXλ
|ρ|<ώ\Ξνμ +¬_ΔlϊΪ ΰΒ4ΟΏςaΝY)'GK5βχ°.ΚιίΝ^i)Ώ
·Qχ|BwΟώεϊͺ
#ύ-~P9ΉΒ―*―
―Θ ('ΓKΌ1ςFgξΗ§\a} xE]leZ€[νwuλ½ZΖ .^΄Ξ*'Ή&]XZ=3*
λf΅ΩN₯j9¬9M65²΄χ¦°ό3|||Nήr/8 N?ΨEΆ9Ήϋm%ΒdZ
.―6ΈΒΚ³¬χuTψζ,ΦΣ ΑtdέqΦλΞ1{ΫΤ±nv€]{W±ύ¬
s.ΗΝΫI]ο¦Ύ} 4ΈΧηΊ°4%
GΙyU ιθ%{GυευΨ}
ιψrΆ½εή’MaWω,ΦΘAΟΌ‘
ΥΑφrVVV09V2;}§Ϊ‘π°Εύ<9LΜ Γ½ ua½gΏ«MRΩ° >>=ωψΘΔιϊΩΊξ©ΒΊaΒ4_ΎόZϋ]VρνΓkZ«WhSl¦ζ%Oήi¨QXΕdwXΕnOXt0Ξ(Ν8%ΧMRaIqσ\oϋοΡNψΦ'₯MΤ`¦\#vJL?WΦw«¬βQν\yXͺΎlή)£±Υf·{^±9ΫΚSjuk ΠΒzUϋΆγδΣζ£&«ΘΤΏzΡΒ26ξ"RΫΡ
EL ύ°Ϊ
auwύ(
DΓͺλκ*,κΊwoυί ]fίΞqΛ]ωΔΈ2wd^u€τ’-qωςTνyrrσnum`V ύ*)'eXj C{
δύυ'οω[+}Ώζ]³ΛώίAΏ3E'σRΚnτ«ψη3gD΅΄w\muρ1»Υ:k
xRωp
εQ;ΎβϋoγCuΎ{Ήβλ:xοk9ΊβλγΗ°ώ°ͺδήΛKD>SΣΫΨ/kgo;Dκ³kηΎjμή+΄aίFBν½uδΈp;oΠά ξν°
Β X ,`°Β X ,`°Β X ,`°Βΐx
ΐ xΌΒφ5ύu ͺxΌΒΜ_Ϋ΄iσώ:5£WΩ’τb5£WΩnj©CXP}Eγf
!7_
° ϊΖ+lΥ½ΟO#μϊ?xBXP#ρ
εun9ΒqW(5;§[° fάγ ±ήΤ-FXPmEγn_}εΔλ
tΧ!,¨Ά’ρ
ίΝ―
WNΠ_° ϊΖ+ΜΙ=~’· P}ΕγΫϊ@ξrT6^αβ£U½΅J4q
£α((ω¦Scb=φπνέAχΏ7©dΕwSCLΈΥZ
u·1>ΓΏEΡx
ς1λ(Db[nQερ
έ\ϊίμπγΚ-ούΧΨϊj¨¦¬g"|kΡλjθώυγ~%z)£τ'(§ Ώu ώΎγ\
χv"#UDΊG-|'³Φ ωΡωJcΪυνθΜoΤLΠά·όώψΤς€EγΤgλά}λρU ―°²° Π]8X4όNΕ~}JMf|aΫBΧ/IFeΖΧfφV£ςF³i{U7τιΒTΡΝvo{―6?5>ΩςΧRam\Xρ.1ώ+ΞΧzΥα'KΦΕ;οjΌBz°χνν`Η+\σjΐcλ\Y=Έ―λI)λΠ:5ΈΘΙ€ηΞ,χπ‘>’Ό§wCίO(tίΠIΪh<θώC>VΤΦpgAhϊΟ-υa9΅Z$:΅χ½ ]~Mjεξυ/ fbΈΦsχ6ΎκSώwv§ gΡ°(Χ -ϊΠν#>j;θZ3%Γ
=ΰ;Iϋ`[Vwυ;PAλΧ5uFΩybσ=ϊ7ΎΣ]ae₯ήΞI]₯Ζ+ά&ΪτΊω6v°κγ>uεHυτΒnI
W#ώ=}΅£νΙ z25Ρbιλ‘
άY-cβ€ΚΈ+ΓΫΙu§?w*}yHίaυήo6μt~Π#G Φι{Ω΅T#!§mzUt³wSl§ Ρψj§L£ξΈξF ΌΒrWΨFό/Β.φί:κWΈ$΅ςΒ?%Z-^¦¬ΔϊATΟ>Θ}(<δ >Πu(<&F nΫΟYΣΓSΞσΛ ϊ°βΧt΄Z«σ³c£H Qύ7buΘξCTOδΉ
λ
εzΫpχπy»
ό6ύeώζξEηX½'GΣΉ)gΰrχoΚ½ΡΙ&bΥΰ
Ζ¨TXjF.λ±έΙΊq'ΟύOΩ°nΉΒrW8JΔ/€
ρ·άΑͺW¨Nΐ Ύ§9κ?H[fΘΥAnΛHwX3άΓzΒr0uL‘|10]₯δ%^Φe7ύαΘϊ-ρωΎJ₯FhνRεΛσ3=ηX ΄UΉndC‘Ί}«ϋ΄ή9ΓX@H5pΞaαΜl2}κ½yHDε€Ν‘a© όΔή¨8,γίrα-¬_δάieΓzίz
ε ―πe‘[οήrΐπͺWψ¦}I³Άͺσ[ιD53(Ϋ gψ@OXΪο©m Yn'ΞΣ΅σ‘±τaς88X^αγjzν>ϊU €ώ’sς^ΊτΥPNχΟ!³U D§«1ΏΜΦϊ°O«©υ Ί.I·Ζ§ου₯½μ_)ΟγςΔ
ΊzΒΚ ¨ν{¬₯αΪγ{Π7#δqwXCmκΐϊXη>ρξ€Β1G>C©» LΧ6mίγG~©
εͺ^(΄°VTΦ/ρuΦUWθHϊΤzΛRU ―0ί‘~±Ώ} ,_LzC>Ψjμο§]άs³?Ξ£Ρ·(¬χ/U
₯rΎ $o φo 9ΌΫ ΤA
ϊl§γ
ϋ¬oΤω(nΰΆ~°ΙSφi6}Jθ¦λότamK ίηςΩ\ΛτBϋMG5±ς|νj΄UjhZ»s°|~ΉE}έγ§ΗΘΘ»qb¨
+7ώγ,)>
yΘΫ―α[_£φ?ό/>κΑΚ7ο°Ζ+€ o"M¦WSnΉU ―pώsφΘ8uσYnΛWη k’ΠͺΞpwφN3|/Ή€=g
E΄+,ΏY""€_Ύv( jZιω 9WXτnItsσ\"¬-kμFν
GΌλYκεIDύ;ΛέξήPοΒυ!
νjΒw]# ώN9'GFφvEςMΒβyοS «¨ηΊσΌX© :tK½ήWL- Φ>ΧΛ Ψρπά{&,ύx
£ͺ:BνWεzο·Νΰ~qΥ΅ψκrΌε―}ώ754½cύλ,mw ₯N Y#~Υfs½«κ«Ώήά0κ`Ρ
½Vυ ς*{ΰ0μν£ΏtΈδΥΟlΥ}S]ΛlMύM©`s―ύ>Κ ζήσmtX[vα‘6]΄°ΜυFmΤΒ2Θ+vvϊ}hΆΒρQGCΓ<ΗΏcαε4§Ι¨έςιp:hΆS(kΠ¨β»
θΤonΙ°BψΎ[ fTXέ©u [grFΩ΅yΕ€,Ο7VΚX£6 λΗτPWa5ΡJϊa9Ραr¦«νη
v0cxΪτ€ποε\Όqk{[ρI^6Ϊ!ΓΚoO3Ύα9ώ΅#W7ΫPΉΒG¦ΙΣ―ώΚ} 7ΥΏgu
μέ1΅v(|Η"Y;Κ3§μUiΦωA»Z2ά\*¬U±[{En βCαk3[ίΓΘ[|;ωq{E£:nΛΆΎQΧι]‘Β*δτ{[u<§.Η>QΑfAj=ωL΄O>C}`Ν’ ΛAΤΤ&Γς΅-€Βi½j&§i
²«Wη ―λΗτPΛauυρέΡΗΗθΜ©~Ο s n6Ί’w2μΟϊwύ5ω ΕXχa²:?ξΡ#!τ5{gYLθΰ ₯ΓκΤ¦3γ=aΗ¦Ά{Σ«oja}²0+++
ΖξΏB]ΆΡέv(άeΰΊΤΦφ0]© λ
ΘgςF΅/ι-Ώ.iΗQΛ/uύήj9¬B³(ϊ7aψL-k£s+ΪΑGΏ±Ϋβ_Ό ""q
Iu²°N ―ήΗzΣn΅~]:,rN΅ ψ?χ- LmJτg)1ό9ΦVm :ΚΣΒ*βλξM λ¨pΏσΆH 5Vν:’ΌRaΡ!&Σ|ωο
uύήj9,½(ΧL‘aΕ;ρ!mΚsh³ΗΉΎίήξk§T°b?ΟμΞ©;Y4χά/O=SfααΕϋ8kΩfΚΉS¨νλΟρ>`uΦνaUY[χ’Ι {«΄ω ίMΚ νwTΌΧΨξ5ϊv5ώa}^("―=ΜργΚj&DΔ«Υϊ{Μ] Φε ΥΨ(τw5ΆΊ-]/ΰ?oΗ] ό3!,`°Β X ,`°Β X ,`°Β X ,¨χG‘%ϊεGU΅d1Σ5okQ80(:Ν.D/ύ ,¨*στY7φι@ Γo yΜzS5gXΨW#υ%
° κΦΉΒZ£>YηS«ϋO ΆAΊUT;¬ΈδδηOBsK y° κ\ai ,P fΘi½vOtΞ° κ\am«ε4EtΣQτΚK‘ ͺΞVI}tΨaΡΦ΅π1»ώ3ΞTϋ +_}¨ΩΡΤ½tΑ~έ* ͺΞ Φυ9-―vq-4'
Ρ° ͺ>ρyB΄ρYD΄X|ΰ7&ρK9³:,Ψ0ΠsLΤ ,¨ͺ4νCUΘΉ΅!&Σ’Ύ±rΑ*ύ§« ,¨>y?T7>^ΏX ΈΣΖ+¬Ί#bΒ(xR‘λ ^_}Z}Ευ5%¦ΚγάU¨ Ζυ)p)r―wΔ/k^Ι
e¨ΰξD+vUΆA Ϊ;ο±;φmέ]Κ―P&Φ)σ@E[Όi<½ΊΔ2―Μ€yG7ΕN7©
2ώ*gα0υ©ςτΌk*gL±»₯¨‘8Vϊͺum©z&υρο "υFy PϊΜSΊ;IπfvwbωΠr―ς*π k"
ν|0QnςNͺ W twWΞx
Q―’ Όhυρτ₯θ§_Φn Ρkε?αΦ Uj:Ηζγ3ͺSκΙ ΅γωjώ΅°έ΅iBΛΨ²¬ϋ΄Τά
Ρl`xφΰ7ΒΛύW‘
υX%ΰϋΧΥa'\:―~:³ͺω]TU-EeΗ+$:Ώ»°Υtδ’MQj.ο2Ξ%9Ξ―:;9DW|'©Gv
ωͺQT\a]hΤͺ^Ίάh@£MtαΎ«NgCS(lκ·;Bkͺ Όήυ=¦}"·yΨ¨1ϊ°ΊϋΎ+WH8]η<ΈhψKNηeyΨiΊnΆαΞΎMάΗ0³3λΘΎςΞή ͺ
ε7΅νξmΪ5Ρύ Va%X3ΤΕΝW?$:Έφz―θLΧͺ%Τ§οIε
ς[Ψ«
Δ’F[,hΫ¦θσο?SyzΫΎΧlόΆϊύ'¬κΗάζ‘`§ υq,ς] ΰ^ΟlUέwUN|R/»Γ* ― Σ^x°όΙ7¨ ε―₯ύ©%Σn±tρ;k»d_J΄]|τ'¬
I§ΗφM΄0»ύ#Σ)&ήf±όΰ
+Eό-Z&NλFτ³΅εDλς1 Rv΅qqXγO]yήΣu&Ζ}l±ψΧδμq«δsή[ΆτλWίv $ξ?σMJ<fέ! ΝGβ'&Τ;gΞ ΌO&ρΎpΌ½i:LύΏ4¦ΩΦx>_~Έ³ *Τ#ΣΓ Ϊ‘π75’ιKΉ²mzΗΘ9ξΥήU£. ι~4^©Ζ±GuΒ¨ΈόΟr·ΔOΆ¦y>β·½Ό5zu΄ΪUλwXΕγG½Ν
σύΌεyΊ°θ49³δ ©¬~Ά0Φι,2{Βκ.O½³:Κ'!Ο©J
2,Ώ7
ΣFSΧ§ΆΚ>yβΠω"ΡΣ©χ_’(¬nιΒ\y -ΟΚΟoυ
'^Ο"ΗΙ»Pιλ +ί@ζΦwόhg|;’1ς»z,|άζZ-a= αzj$^¦~b~½gsίwͺ.γ)y½WNΡ9ΦϋΦt(²άΐδώΙψΆamϊίώM1Θgή_»ιΒ~½uΏͺ
5Ό μηπτΐXνθ~Ί’ρϋώ%aWθL£ΚΒ
OOοΨ³ ό°FΎ’κ ΓZμήΐuεΏΧ©F€χλΥ;,ΕΌV
.§~ΘΓϊ#Λ.ησςτω΄:q₯EzΣgώt$΅;¬mΪh(ο,GδΕ―ελό8uLϋ’·/ w.kA΅__"Γϊ«kM§h%ΓAΠόG\KfΛΤλ1X»δλP€άπ7Χθxέw2cΥςΞW[όαxwwΆΒ- ΣξO
₯"θ:ύπΝ¬³¨Ωό»Γ*―0τΑ·nu(μ³ )§Ό°ΜΙΛΣΣ;YRΗΛ° ?:>Ω±Ε΅ή$|UΪ(R0 ³»QEa5jLΌΆZXκΙτ― χΣJ‘Ν3G«πgυψwU4^‘AL8sΎ²°h<Γψ9VΝeΛήX;Σ-ay~mC
υToyιύlJ£W/λ
τtδOςgΏXΫΞ^gΏ_LΟzκd&ΊψKύΫί ogΟ¨ωZX/υξ
ιΒΊsΦ °Τ¨Ο%Ή? ³uPcjώAΗ
zoιkΦ α:j~ Ώφ W§>ΈΓ
ν½’Ϋ₯ξ°rcU:?§έ{όΔ-Ϊΐ§υΏ€ωΛΥγκ7
εγδβΥZX³uaνΣΞg5ϋϊ[ψU4^a&πβΏ*
λωϊΪ.ΟsECaηΗT2¬K―Ι'³] Δ
Ϊ`,
ΛοΪpω4α~SΚ_;ΝaΝS·δS ϊ=Ά_"rΤ°k΅cΧWεδΠΏΤ\DλΒϊ.δkρπPy―Ά?(E½¬ dX^vν ½j<%Τ§½=ς\υΌmν
Υ%iΏv&5Ώ£ώ―^Uc'΅ΊE=ΥΩZ]X)V5vπseΒ:.ή%υϋΔj\²ό+Γ*gΌB₯²CaΣΉπηD"ΫάύΆaM2-ιBW\aεYΦ»Βzp^tPΏTΦϋ?ω,3F C5Όμ
ντδΥΕA‘ωΪ=φ·χ3
ΣΥYr« ―τβCaά{t PξΊ]=ψΞc¦PύΨ Ϊ_άD―bΝτV/OXΙopmλθΒS
ςόjyyΒ%υFΑwb|AθΩςΨΨ/|βαΠ₯ΪP9χ£΄8 J>¦ ZXO΅οΥΩΎ=BYmΈVσsό ίΟd χπS»-Σ
E7Χε½ΩΊLXήW'Μ»zM³MG©VΤrXεWx°δκ
ΖκC(¦ΨL!ΝKΌΣP£°Ιξ°6ͺAUXΆΤsdX?FdΏO30Vlqe|όΏ*΄ΫRεΑΡ₯BϋKΘ°θ~ΥΊΊψνVρΏλ!Υ₯^J/RΧ/Υ[Θ«½°χ{}3άν½.χ₯΅|χίπΒ9 eXYk·ο΄wήΧΒ΄@ ͺϊ%w°ZνΟxΎΑ£©ςκY6{DΘ;s,φ#ϊRΎ°+oo₯{(2σλΙΒς·|{Λκώλ
Λι"bΩj}X·t°K
EΞΡΒ$«wP_[C΅’Γ+―πΆE.³ΜoηΈrγ
0Έί 6l+Ό&qaΪΛ:ΗΈΓξ%'Έυ ξ-:ΚΫpS^AQΕN ¬=nG’ά=u7=έ»ύ)εxρΨζkκψΥu―‘IΜΝΣύeΠΞ0ν Οo}ο
εd2~z9ίξΑqΪ4 άPΕyuΥaX.-Ή³7Ψ/Ήδε&ΖUΩάόδΑ
―kΠ(8xhΘλoόξά ͺ λ&λU}b½
aέAϋBΔ7¨ζ7TsλίΉίqKΙωmT|γk~wΒ X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,`°Β X ,¨ͺ%CΥΜO_¦gΎ‘-sUfTTyϊ¬b[Ίΰ¦qΆμϊΕk!,¨Ίu°€N³ά3ΤΒ X ,`°Β |βσhγ³(ΨΗ§ύ~ P’<vb©Ο^έJ ͺ*M(Kκi3’ QOmf n% d [H/§ %tEXtdate:create 2016-03-24T21:04:02+01:00±γΈ %tEXtdate:modify 2016-03-24T21:04:02+01:00ΐΎ, tEXtSoftware www.inkscape.orgξ< IENDB` go-tools-2021.1.2/internal/ 0000775 0000000 0000000 00000000000 14143223131 0015310 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/cache/ 0000775 0000000 0000000 00000000000 14143223131 0016353 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/cache/UPSTREAM 0000664 0000000 0000000 00000000610 14143223131 0017533 0 ustar 00root root 0000000 0000000 This package is a copy of cmd/go/internal/cache.
Differences from upstream:
- we continue to use renameio instead of lockedfile for writing trim.txt
- we still use I/O helpers that work with earlier versions of Go.
- we use a cache directory specific to Staticcheck
- we use a Staticcheck-specific salt
The last upstream commit we've looked at was:
06ac303f6a14b133254f757e54599c48e3c2a4ad
go-tools-2021.1.2/internal/cache/cache.go 0000664 0000000 0000000 00000041250 14143223131 0017747 0 ustar 00root root 0000000 0000000 // 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 cache implements a build artifact cache.
//
// This package is a slightly modified fork of Go's
// cmd/go/internal/cache package.
package cache
import (
"bytes"
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
"io"
"io/ioutil"
"os"
"path/filepath"
"strconv"
"strings"
"time"
"honnef.co/go/tools/internal/renameio"
)
// An ActionID is a cache action key, the hash of a complete description of a
// repeatable computation (command line, environment variables,
// input file contents, executable contents).
type ActionID [HashSize]byte
// An OutputID is a cache output key, the hash of an output of a computation.
type OutputID [HashSize]byte
// A Cache is a package cache, backed by a file system directory tree.
type Cache struct {
dir string
now func() time.Time
salt []byte
}
// Open opens and returns the cache in the given directory.
//
// It is safe for multiple processes on a single machine to use the
// same cache directory in a local file system simultaneously.
// They will coordinate using operating system file locks and may
// duplicate effort but will not corrupt the cache.
//
// However, it is NOT safe for multiple processes on different machines
// to share a cache directory (for example, if the directory were stored
// in a network file system). File locking is notoriously unreliable in
// network file systems and may not suffice to protect the cache.
//
func Open(dir string) (*Cache, error) {
info, err := os.Stat(dir)
if err != nil {
return nil, err
}
if !info.IsDir() {
return nil, &os.PathError{Op: "open", Path: dir, Err: fmt.Errorf("not a directory")}
}
for i := 0; i < 256; i++ {
name := filepath.Join(dir, fmt.Sprintf("%02x", i))
if err := os.MkdirAll(name, 0777); err != nil {
return nil, err
}
}
c := &Cache{
dir: dir,
now: time.Now,
}
return c, nil
}
func (c *Cache) SetSalt(b []byte) {
c.salt = b
}
// fileName returns the name of the file corresponding to the given id.
func (c *Cache) fileName(id [HashSize]byte, key string) string {
return filepath.Join(c.dir, fmt.Sprintf("%02x", id[0]), fmt.Sprintf("%x", id)+"-"+key)
}
// An entryNotFoundError indicates that a cache entry was not found, with an
// optional underlying reason.
type entryNotFoundError struct {
Err error
}
func (e *entryNotFoundError) Error() string {
if e.Err == nil {
return "cache entry not found"
}
return fmt.Sprintf("cache entry not found: %v", e.Err)
}
func (e *entryNotFoundError) Unwrap() error {
return e.Err
}
const (
// action entry file is "v1 \n"
hexSize = HashSize * 2
entrySize = 2 + 1 + hexSize + 1 + hexSize + 1 + 20 + 1 + 20 + 1
)
// verify controls whether to run the cache in verify mode.
// In verify mode, the cache always returns errMissing from Get
// but then double-checks in Put that the data being written
// exactly matches any existing entry. This provides an easy
// way to detect program behavior that would have been different
// had the cache entry been returned from Get.
//
// verify is enabled by setting the environment variable
// GODEBUG=gocacheverify=1.
var verify = false
var errVerifyMode = errors.New("gocacheverify=1")
// DebugTest is set when GODEBUG=gocachetest=1 is in the environment.
var DebugTest = false
func init() { initEnv() }
func initEnv() {
verify = false
debugHash = false
debug := strings.Split(os.Getenv("GODEBUG"), ",")
for _, f := range debug {
if f == "gocacheverify=1" {
verify = true
}
if f == "gocachehash=1" {
debugHash = true
}
if f == "gocachetest=1" {
DebugTest = true
}
}
}
// Get looks up the action ID in the cache,
// returning the corresponding output ID and file size, if any.
// Note that finding an output ID does not guarantee that the
// saved file for that output ID is still available.
func (c *Cache) Get(id ActionID) (Entry, error) {
if verify {
return Entry{}, &entryNotFoundError{Err: errVerifyMode}
}
return c.get(id)
}
type Entry struct {
OutputID OutputID
Size int64
Time time.Time
}
// get is Get but does not respect verify mode, so that Put can use it.
func (c *Cache) get(id ActionID) (Entry, error) {
missing := func(reason error) (Entry, error) {
return Entry{}, &entryNotFoundError{Err: reason}
}
f, err := os.Open(c.fileName(id, "a"))
if err != nil {
return missing(err)
}
defer f.Close()
entry := make([]byte, entrySize+1) // +1 to detect whether f is too long
if n, err := io.ReadFull(f, entry); n > entrySize {
return missing(errors.New("too long"))
} else if err != io.ErrUnexpectedEOF {
if err == io.EOF {
return missing(errors.New("file is empty"))
}
return missing(err)
} else if n < entrySize {
return missing(errors.New("entry file incomplete"))
}
if entry[0] != 'v' || entry[1] != '1' || entry[2] != ' ' || entry[3+hexSize] != ' ' || entry[3+hexSize+1+hexSize] != ' ' || entry[3+hexSize+1+hexSize+1+20] != ' ' || entry[entrySize-1] != '\n' {
return missing(errors.New("invalid header"))
}
eid, entry := entry[3:3+hexSize], entry[3+hexSize:]
eout, entry := entry[1:1+hexSize], entry[1+hexSize:]
esize, entry := entry[1:1+20], entry[1+20:]
//lint:ignore SA4006 See https://github.com/dominikh/go-tools/issues/465
etime, entry := entry[1:1+20], entry[1+20:]
var buf [HashSize]byte
if _, err := hex.Decode(buf[:], eid); err != nil {
return missing(fmt.Errorf("decoding ID: %v", err))
} else if buf != id {
return missing(errors.New("mismatched ID"))
}
if _, err := hex.Decode(buf[:], eout); err != nil {
return missing(fmt.Errorf("decoding output ID: %v", err))
}
i := 0
for i < len(esize) && esize[i] == ' ' {
i++
}
size, err := strconv.ParseInt(string(esize[i:]), 10, 64)
if err != nil {
return missing(fmt.Errorf("parsing size: %v", err))
} else if size < 0 {
return missing(errors.New("negative size"))
}
i = 0
for i < len(etime) && etime[i] == ' ' {
i++
}
tm, err := strconv.ParseInt(string(etime[i:]), 10, 64)
if err != nil {
return missing(fmt.Errorf("parsing timestamp: %v", err))
} else if tm < 0 {
return missing(errors.New("negative timestamp"))
}
c.used(c.fileName(id, "a"))
return Entry{buf, size, time.Unix(0, tm)}, nil
}
// GetFile looks up the action ID in the cache and returns
// the name of the corresponding data file.
func (c *Cache) GetFile(id ActionID) (file string, entry Entry, err error) {
entry, err = c.Get(id)
if err != nil {
return "", Entry{}, err
}
file = c.OutputFile(entry.OutputID)
info, err := os.Stat(file)
if err != nil {
return "", Entry{}, &entryNotFoundError{Err: err}
}
if info.Size() != entry.Size {
return "", Entry{}, &entryNotFoundError{Err: errors.New("file incomplete")}
}
return file, entry, nil
}
// GetBytes looks up the action ID in the cache and returns
// the corresponding output bytes.
// GetBytes should only be used for data that can be expected to fit in memory.
func (c *Cache) GetBytes(id ActionID) ([]byte, Entry, error) {
entry, err := c.Get(id)
if err != nil {
return nil, entry, err
}
data, _ := ioutil.ReadFile(c.OutputFile(entry.OutputID))
if sha256.Sum256(data) != entry.OutputID {
return nil, entry, &entryNotFoundError{Err: errors.New("bad checksum")}
}
return data, entry, nil
}
// OutputFile returns the name of the cache file storing output with the given OutputID.
func (c *Cache) OutputFile(out OutputID) string {
file := c.fileName(out, "d")
c.used(file)
return file
}
// Time constants for cache expiration.
//
// We set the mtime on a cache file on each use, but at most one per mtimeInterval (1 hour),
// to avoid causing many unnecessary inode updates. The mtimes therefore
// roughly reflect "time of last use" but may in fact be older by at most an hour.
//
// We scan the cache for entries to delete at most once per trimInterval (1 day).
//
// When we do scan the cache, we delete entries that have not been used for
// at least trimLimit (5 days). Statistics gathered from a month of usage by
// Go developers found that essentially all reuse of cached entries happened
// within 5 days of the previous reuse. See golang.org/issue/22990.
const (
mtimeInterval = 1 * time.Hour
trimInterval = 24 * time.Hour
trimLimit = 5 * 24 * time.Hour
)
// used makes a best-effort attempt to update mtime on file,
// so that mtime reflects cache access time.
//
// Because the reflection only needs to be approximate,
// and to reduce the amount of disk activity caused by using
// cache entries, used only updates the mtime if the current
// mtime is more than an hour old. This heuristic eliminates
// nearly all of the mtime updates that would otherwise happen,
// while still keeping the mtimes useful for cache trimming.
func (c *Cache) used(file string) {
info, err := os.Stat(file)
if err == nil && c.now().Sub(info.ModTime()) < mtimeInterval {
return
}
os.Chtimes(file, c.now(), c.now())
}
// Trim removes old cache entries that are likely not to be reused.
func (c *Cache) Trim() {
now := c.now()
// We maintain in dir/trim.txt the time of the last completed cache trim.
// If the cache has been trimmed recently enough, do nothing.
// This is the common case.
data, _ := renameio.ReadFile(filepath.Join(c.dir, "trim.txt"))
t, err := strconv.ParseInt(strings.TrimSpace(string(data)), 10, 64)
if err == nil && now.Sub(time.Unix(t, 0)) < trimInterval {
return
}
// Trim each of the 256 subdirectories.
// We subtract an additional mtimeInterval
// to account for the imprecision of our "last used" mtimes.
cutoff := now.Add(-trimLimit - mtimeInterval)
for i := 0; i < 256; i++ {
subdir := filepath.Join(c.dir, fmt.Sprintf("%02x", i))
c.trimSubdir(subdir, cutoff)
}
// Ignore errors from here: if we don't write the complete timestamp, the
// cache will appear older than it is, and we'll trim it again next time.
renameio.WriteFile(filepath.Join(c.dir, "trim.txt"), []byte(fmt.Sprintf("%d", now.Unix())), 0666)
}
// trimSubdir trims a single cache subdirectory.
func (c *Cache) trimSubdir(subdir string, cutoff time.Time) {
// Read all directory entries from subdir before removing
// any files, in case removing files invalidates the file offset
// in the directory scan. Also, ignore error from f.Readdirnames,
// because we don't care about reporting the error and we still
// want to process any entries found before the error.
f, err := os.Open(subdir)
if err != nil {
return
}
names, _ := f.Readdirnames(-1)
f.Close()
for _, name := range names {
// Remove only cache entries (xxxx-a and xxxx-d).
if !strings.HasSuffix(name, "-a") && !strings.HasSuffix(name, "-d") {
continue
}
entry := filepath.Join(subdir, name)
info, err := os.Stat(entry)
if err == nil && info.ModTime().Before(cutoff) {
os.Remove(entry)
}
}
}
// putIndexEntry adds an entry to the cache recording that executing the action
// with the given id produces an output with the given output id (hash) and size.
func (c *Cache) putIndexEntry(id ActionID, out OutputID, size int64, allowVerify bool) error {
// Note: We expect that for one reason or another it may happen
// that repeating an action produces a different output hash
// (for example, if the output contains a time stamp or temp dir name).
// While not ideal, this is also not a correctness problem, so we
// don't make a big deal about it. In particular, we leave the action
// cache entries writable specifically so that they can be overwritten.
//
// Setting GODEBUG=gocacheverify=1 does make a big deal:
// in verify mode we are double-checking that the cache entries
// are entirely reproducible. As just noted, this may be unrealistic
// in some cases but the check is also useful for shaking out real bugs.
entry := fmt.Sprintf("v1 %x %x %20d %20d\n", id, out, size, time.Now().UnixNano())
if verify && allowVerify {
old, err := c.get(id)
if err == nil && (old.OutputID != out || old.Size != size) {
// panic to show stack trace, so we can see what code is generating this cache entry.
msg := fmt.Sprintf("go: internal cache error: cache verify failed: id=%x changed:<<<\n%s\n>>>\nold: %x %d\nnew: %x %d", id, reverseHash(id), out, size, old.OutputID, old.Size)
panic(msg)
}
}
file := c.fileName(id, "a")
// Copy file to cache directory.
mode := os.O_WRONLY | os.O_CREATE
f, err := os.OpenFile(file, mode, 0666)
if err != nil {
return err
}
_, err = f.WriteString(entry)
if err == nil {
// Truncate the file only *after* writing it.
// (This should be a no-op, but truncate just in case of previous corruption.)
//
// This differs from ioutil.WriteFile, which truncates to 0 *before* writing
// via os.O_TRUNC. Truncating only after writing ensures that a second write
// of the same content to the same file is idempotent, and does not β even
// temporarily! β undo the effect of the first write.
err = f.Truncate(int64(len(entry)))
}
if closeErr := f.Close(); err == nil {
err = closeErr
}
if err != nil {
// TODO(bcmills): This Remove potentially races with another go command writing to file.
// Can we eliminate it?
os.Remove(file)
return err
}
os.Chtimes(file, c.now(), c.now()) // mainly for tests
return nil
}
// Put stores the given output in the cache as the output for the action ID.
// It may read file twice. The content of file must not change between the two passes.
func (c *Cache) Put(id ActionID, file io.ReadSeeker) (OutputID, int64, error) {
return c.put(id, file, true)
}
// PutNoVerify is like Put but disables the verify check
// when GODEBUG=goverifycache=1 is set.
// It is meant for data that is OK to cache but that we expect to vary slightly from run to run,
// like test output containing times and the like.
func (c *Cache) PutNoVerify(id ActionID, file io.ReadSeeker) (OutputID, int64, error) {
return c.put(id, file, false)
}
func (c *Cache) put(id ActionID, file io.ReadSeeker, allowVerify bool) (OutputID, int64, error) {
// Compute output ID.
h := sha256.New()
if _, err := file.Seek(0, 0); err != nil {
return OutputID{}, 0, err
}
size, err := io.Copy(h, file)
if err != nil {
return OutputID{}, 0, err
}
var out OutputID
h.Sum(out[:0])
// Copy to cached output file (if not already present).
if err := c.copyFile(file, out, size); err != nil {
return out, size, err
}
// Add to cache index.
return out, size, c.putIndexEntry(id, out, size, allowVerify)
}
// PutBytes stores the given bytes in the cache as the output for the action ID.
func (c *Cache) PutBytes(id ActionID, data []byte) error {
_, _, err := c.Put(id, bytes.NewReader(data))
return err
}
// copyFile copies file into the cache, expecting it to have the given
// output ID and size, if that file is not present already.
func (c *Cache) copyFile(file io.ReadSeeker, out OutputID, size int64) error {
name := c.fileName(out, "d")
info, err := os.Stat(name)
if err == nil && info.Size() == size {
// Check hash.
if f, err := os.Open(name); err == nil {
h := sha256.New()
io.Copy(h, f)
f.Close()
var out2 OutputID
h.Sum(out2[:0])
if out == out2 {
return nil
}
}
// Hash did not match. Fall through and rewrite file.
}
// Copy file to cache directory.
mode := os.O_RDWR | os.O_CREATE
if err == nil && info.Size() > size { // shouldn't happen but fix in case
mode |= os.O_TRUNC
}
f, err := os.OpenFile(name, mode, 0666)
if err != nil {
return err
}
defer f.Close()
if size == 0 {
// File now exists with correct size.
// Only one possible zero-length file, so contents are OK too.
// Early return here makes sure there's a "last byte" for code below.
return nil
}
// From here on, if any of the I/O writing the file fails,
// we make a best-effort attempt to truncate the file f
// before returning, to avoid leaving bad bytes in the file.
// Copy file to f, but also into h to double-check hash.
if _, err := file.Seek(0, 0); err != nil {
f.Truncate(0)
return err
}
h := sha256.New()
w := io.MultiWriter(f, h)
if _, err := io.CopyN(w, file, size-1); err != nil {
f.Truncate(0)
return err
}
// Check last byte before writing it; writing it will make the size match
// what other processes expect to find and might cause them to start
// using the file.
buf := make([]byte, 1)
if _, err := file.Read(buf); err != nil {
f.Truncate(0)
return err
}
h.Write(buf)
sum := h.Sum(nil)
if !bytes.Equal(sum, out[:]) {
f.Truncate(0)
return fmt.Errorf("file content changed underfoot")
}
// Commit cache file entry.
if _, err := f.Write(buf); err != nil {
f.Truncate(0)
return err
}
if err := f.Close(); err != nil {
// Data might not have been written,
// but file may look like it is the right size.
// To be extra careful, remove cached file.
os.Remove(name)
return err
}
os.Chtimes(name, c.now(), c.now()) // mainly for tests
return nil
}
go-tools-2021.1.2/internal/cache/cache_test.go 0000664 0000000 0000000 00000016033 14143223131 0021007 0 ustar 00root root 0000000 0000000 // 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 cache
import (
"bytes"
"encoding/binary"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"testing"
"time"
)
func init() {
verify = false // even if GODEBUG is set
}
func TestBasic(t *testing.T) {
dir, err := ioutil.TempDir("", "cachetest-")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(dir)
_, err = Open(filepath.Join(dir, "notexist"))
if err == nil {
t.Fatal(`Open("tmp/notexist") succeeded, want failure`)
}
cdir := filepath.Join(dir, "c1")
if err := os.Mkdir(cdir, 0777); err != nil {
t.Fatal(err)
}
c1, err := Open(cdir)
if err != nil {
t.Fatalf("Open(c1) (create): %v", err)
}
if err := c1.putIndexEntry(dummyID(1), dummyID(12), 13, true); err != nil {
t.Fatalf("addIndexEntry: %v", err)
}
if err := c1.putIndexEntry(dummyID(1), dummyID(2), 3, true); err != nil { // overwrite entry
t.Fatalf("addIndexEntry: %v", err)
}
if entry, err := c1.Get(dummyID(1)); err != nil || entry.OutputID != dummyID(2) || entry.Size != 3 {
t.Fatalf("c1.Get(1) = %x, %v, %v, want %x, %v, nil", entry.OutputID, entry.Size, err, dummyID(2), 3)
}
c2, err := Open(cdir)
if err != nil {
t.Fatalf("Open(c2) (reuse): %v", err)
}
if entry, err := c2.Get(dummyID(1)); err != nil || entry.OutputID != dummyID(2) || entry.Size != 3 {
t.Fatalf("c2.Get(1) = %x, %v, %v, want %x, %v, nil", entry.OutputID, entry.Size, err, dummyID(2), 3)
}
if err := c2.putIndexEntry(dummyID(2), dummyID(3), 4, true); err != nil {
t.Fatalf("addIndexEntry: %v", err)
}
if entry, err := c1.Get(dummyID(2)); err != nil || entry.OutputID != dummyID(3) || entry.Size != 4 {
t.Fatalf("c1.Get(2) = %x, %v, %v, want %x, %v, nil", entry.OutputID, entry.Size, err, dummyID(3), 4)
}
}
func TestGrowth(t *testing.T) {
dir, err := ioutil.TempDir("", "cachetest-")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(dir)
c, err := Open(dir)
if err != nil {
t.Fatalf("Open: %v", err)
}
n := 10000
if testing.Short() {
n = 10
}
for i := 0; i < n; i++ {
if err := c.putIndexEntry(dummyID(i), dummyID(i*99), int64(i)*101, true); err != nil {
t.Fatalf("addIndexEntry: %v", err)
}
id := ActionID(dummyID(i))
entry, err := c.Get(id)
if err != nil {
t.Fatalf("Get(%x): %v", id, err)
}
if entry.OutputID != dummyID(i*99) || entry.Size != int64(i)*101 {
t.Errorf("Get(%x) = %x, %d, want %x, %d", id, entry.OutputID, entry.Size, dummyID(i*99), int64(i)*101)
}
}
for i := 0; i < n; i++ {
id := ActionID(dummyID(i))
entry, err := c.Get(id)
if err != nil {
t.Fatalf("Get2(%x): %v", id, err)
}
if entry.OutputID != dummyID(i*99) || entry.Size != int64(i)*101 {
t.Errorf("Get2(%x) = %x, %d, want %x, %d", id, entry.OutputID, entry.Size, dummyID(i*99), int64(i)*101)
}
}
}
func TestVerifyPanic(t *testing.T) {
os.Setenv("GODEBUG", "gocacheverify=1")
initEnv()
defer func() {
os.Unsetenv("GODEBUG")
verify = false
}()
if !verify {
t.Fatal("initEnv did not set verify")
}
dir, err := ioutil.TempDir("", "cachetest-")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(dir)
c, err := Open(dir)
if err != nil {
t.Fatalf("Open: %v", err)
}
id := ActionID(dummyID(1))
if err := c.PutBytes(id, []byte("abc")); err != nil {
t.Fatal(err)
}
defer func() {
if err := recover(); err != nil {
t.Log(err)
return
}
}()
c.PutBytes(id, []byte("def"))
t.Fatal("mismatched Put did not panic in verify mode")
}
func dummyID(x int) [HashSize]byte {
var out [HashSize]byte
binary.LittleEndian.PutUint64(out[:], uint64(x))
return out
}
func TestCacheTrim(t *testing.T) {
dir, err := ioutil.TempDir("", "cachetest-")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(dir)
c, err := Open(dir)
if err != nil {
t.Fatalf("Open: %v", err)
}
const start = 1000000000
now := int64(start)
c.now = func() time.Time { return time.Unix(now, 0) }
checkTime := func(name string, mtime int64) {
t.Helper()
file := filepath.Join(c.dir, name[:2], name)
info, err := os.Stat(file)
if err != nil {
t.Fatal(err)
}
if info.ModTime().Unix() != mtime {
t.Fatalf("%s mtime = %d, want %d", name, info.ModTime().Unix(), mtime)
}
}
id := ActionID(dummyID(1))
c.PutBytes(id, []byte("abc"))
entry, _ := c.Get(id)
c.PutBytes(ActionID(dummyID(2)), []byte("def"))
mtime := now
checkTime(fmt.Sprintf("%x-a", id), mtime)
checkTime(fmt.Sprintf("%x-d", entry.OutputID), mtime)
// Get should not change recent mtimes.
now = start + 10
c.Get(id)
checkTime(fmt.Sprintf("%x-a", id), mtime)
checkTime(fmt.Sprintf("%x-d", entry.OutputID), mtime)
// Get should change distant mtimes.
now = start + 5000
mtime2 := now
if _, err := c.Get(id); err != nil {
t.Fatal(err)
}
c.OutputFile(entry.OutputID)
checkTime(fmt.Sprintf("%x-a", id), mtime2)
checkTime(fmt.Sprintf("%x-d", entry.OutputID), mtime2)
// Trim should leave everything alone: it's all too new.
c.Trim()
if _, err := c.Get(id); err != nil {
t.Fatal(err)
}
c.OutputFile(entry.OutputID)
data, err := ioutil.ReadFile(filepath.Join(dir, "trim.txt"))
if err != nil {
t.Fatal(err)
}
checkTime(fmt.Sprintf("%x-a", dummyID(2)), start)
// Trim less than a day later should not do any work at all.
now = start + 80000
c.Trim()
if _, err := c.Get(id); err != nil {
t.Fatal(err)
}
c.OutputFile(entry.OutputID)
data2, err := ioutil.ReadFile(filepath.Join(dir, "trim.txt"))
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(data, data2) {
t.Fatalf("second trim did work: %q -> %q", data, data2)
}
// Fast forward and do another trim just before the 5 day cutoff.
// Note that because of usedQuantum the cutoff is actually 5 days + 1 hour.
// We used c.Get(id) just now, so 5 days later it should still be kept.
// On the other hand almost a full day has gone by since we wrote dummyID(2)
// and we haven't looked at it since, so 5 days later it should be gone.
now += 5 * 86400
checkTime(fmt.Sprintf("%x-a", dummyID(2)), start)
c.Trim()
if _, err := c.Get(id); err != nil {
t.Fatal(err)
}
c.OutputFile(entry.OutputID)
mtime3 := now
if _, err := c.Get(dummyID(2)); err == nil { // haven't done a Get for this since original write above
t.Fatalf("Trim did not remove dummyID(2)")
}
// The c.Get(id) refreshed id's mtime again.
// Check that another 5 days later it is still not gone,
// but check by using checkTime, which doesn't bring mtime forward.
now += 5 * 86400
c.Trim()
checkTime(fmt.Sprintf("%x-a", id), mtime3)
checkTime(fmt.Sprintf("%x-d", entry.OutputID), mtime3)
// Half a day later Trim should still be a no-op, because there was a Trim recently.
// Even though the entry for id is now old enough to be trimmed,
// it gets a reprieve until the time comes for a new Trim scan.
now += 86400 / 2
c.Trim()
checkTime(fmt.Sprintf("%x-a", id), mtime3)
checkTime(fmt.Sprintf("%x-d", entry.OutputID), mtime3)
// Another half a day later, Trim should actually run, and it should remove id.
now += 86400/2 + 1
c.Trim()
if _, err := c.Get(dummyID(1)); err == nil {
t.Fatal("Trim did not remove dummyID(1)")
}
}
go-tools-2021.1.2/internal/cache/default.go 0000664 0000000 0000000 00000004300 14143223131 0020323 0 ustar 00root root 0000000 0000000 // 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 cache
import (
"fmt"
"io/ioutil"
"log"
"os"
"path/filepath"
"sync"
)
// Default returns the default cache to use.
func Default() (*Cache, error) {
defaultOnce.Do(initDefaultCache)
return defaultCache, defaultDirErr
}
var (
defaultOnce sync.Once
defaultCache *Cache
)
// cacheREADME is a message stored in a README in the cache directory.
// Because the cache lives outside the normal Go trees, we leave the
// README as a courtesy to explain where it came from.
const cacheREADME = `This directory holds cached build artifacts from staticcheck.
`
// initDefaultCache does the work of finding the default cache
// the first time Default is called.
func initDefaultCache() {
dir := DefaultDir()
if err := os.MkdirAll(dir, 0777); err != nil {
log.Fatalf("failed to initialize build cache at %s: %s\n", dir, err)
}
if _, err := os.Stat(filepath.Join(dir, "README")); err != nil {
// Best effort.
ioutil.WriteFile(filepath.Join(dir, "README"), []byte(cacheREADME), 0666)
}
c, err := Open(dir)
if err != nil {
log.Fatalf("failed to initialize build cache at %s: %s\n", dir, err)
}
defaultCache = c
}
var (
defaultDirOnce sync.Once
defaultDir string
defaultDirErr error
)
// DefaultDir returns the effective STATICCHECK_CACHE setting.
func DefaultDir() string {
// Save the result of the first call to DefaultDir for later use in
// initDefaultCache. cmd/go/main.go explicitly sets GOCACHE so that
// subprocesses will inherit it, but that means initDefaultCache can't
// otherwise distinguish between an explicit "off" and a UserCacheDir error.
defaultDirOnce.Do(func() {
defaultDir = os.Getenv("STATICCHECK_CACHE")
if filepath.IsAbs(defaultDir) {
return
}
if defaultDir != "" {
defaultDirErr = fmt.Errorf("STATICCHECK_CACHE is not an absolute path")
return
}
// Compute default location.
dir, err := os.UserCacheDir()
if err != nil {
defaultDirErr = fmt.Errorf("STATICCHECK_CACHE is not defined and %v", err)
return
}
defaultDir = filepath.Join(dir, "staticcheck")
})
return defaultDir
}
go-tools-2021.1.2/internal/cache/hash.go 0000664 0000000 0000000 00000007330 14143223131 0017630 0 ustar 00root root 0000000 0000000 // 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 cache
import (
"bytes"
"crypto/sha256"
"fmt"
"hash"
"io"
"os"
"sync"
)
var debugHash = false // set when GODEBUG=gocachehash=1
// HashSize is the number of bytes in a hash.
const HashSize = 32
// A Hash provides access to the canonical hash function used to index the cache.
// The current implementation uses salted SHA256, but clients must not assume this.
type Hash struct {
h hash.Hash
name string // for debugging
buf *bytes.Buffer // for verify
}
// Subkey returns an action ID corresponding to mixing a parent
// action ID with a string description of the subkey.
func Subkey(parent ActionID, desc string) ActionID {
h := sha256.New()
h.Write([]byte("subkey:"))
h.Write(parent[:])
h.Write([]byte(desc))
var out ActionID
h.Sum(out[:0])
if debugHash {
fmt.Fprintf(os.Stderr, "HASH subkey %x %q = %x\n", parent, desc, out)
}
if verify {
hashDebug.Lock()
hashDebug.m[out] = fmt.Sprintf("subkey %x %q", parent, desc)
hashDebug.Unlock()
}
return out
}
// NewHash returns a new Hash.
// The caller is expected to Write data to it and then call Sum.
func (c *Cache) NewHash(name string) *Hash {
h := &Hash{h: sha256.New(), name: name}
if debugHash {
fmt.Fprintf(os.Stderr, "HASH[%s]\n", h.name)
}
h.Write(c.salt)
if verify {
h.buf = new(bytes.Buffer)
}
return h
}
// Write writes data to the running hash.
func (h *Hash) Write(b []byte) (int, error) {
if debugHash {
fmt.Fprintf(os.Stderr, "HASH[%s]: %q\n", h.name, b)
}
if h.buf != nil {
h.buf.Write(b)
}
return h.h.Write(b)
}
// Sum returns the hash of the data written previously.
func (h *Hash) Sum() [HashSize]byte {
var out [HashSize]byte
h.h.Sum(out[:0])
if debugHash {
fmt.Fprintf(os.Stderr, "HASH[%s]: %x\n", h.name, out)
}
if h.buf != nil {
hashDebug.Lock()
if hashDebug.m == nil {
hashDebug.m = make(map[[HashSize]byte]string)
}
hashDebug.m[out] = h.buf.String()
hashDebug.Unlock()
}
return out
}
// In GODEBUG=gocacheverify=1 mode,
// hashDebug holds the input to every computed hash ID,
// so that we can work backward from the ID involved in a
// cache entry mismatch to a description of what should be there.
var hashDebug struct {
sync.Mutex
m map[[HashSize]byte]string
}
// reverseHash returns the input used to compute the hash id.
func reverseHash(id [HashSize]byte) string {
hashDebug.Lock()
s := hashDebug.m[id]
hashDebug.Unlock()
return s
}
var hashFileCache struct {
sync.Mutex
m map[string][HashSize]byte
}
// FileHash returns the hash of the named file.
// It caches repeated lookups for a given file,
// and the cache entry for a file can be initialized
// using SetFileHash.
// The hash used by FileHash is not the same as
// the hash used by NewHash.
func FileHash(file string) ([HashSize]byte, error) {
hashFileCache.Lock()
out, ok := hashFileCache.m[file]
hashFileCache.Unlock()
if ok {
return out, nil
}
h := sha256.New()
f, err := os.Open(file)
if err != nil {
if debugHash {
fmt.Fprintf(os.Stderr, "HASH %s: %v\n", file, err)
}
return [HashSize]byte{}, err
}
_, err = io.Copy(h, f)
f.Close()
if err != nil {
if debugHash {
fmt.Fprintf(os.Stderr, "HASH %s: %v\n", file, err)
}
return [HashSize]byte{}, err
}
h.Sum(out[:0])
if debugHash {
fmt.Fprintf(os.Stderr, "HASH %s: %x\n", file, out)
}
SetFileHash(file, out)
return out, nil
}
// SetFileHash sets the hash returned by FileHash for file.
func SetFileHash(file string, sum [HashSize]byte) {
hashFileCache.Lock()
if hashFileCache.m == nil {
hashFileCache.m = make(map[string][HashSize]byte)
}
hashFileCache.m[file] = sum
hashFileCache.Unlock()
}
go-tools-2021.1.2/internal/cache/hash_test.go 0000664 0000000 0000000 00000002060 14143223131 0020662 0 ustar 00root root 0000000 0000000 // 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 cache
import (
"fmt"
"io/ioutil"
"os"
"testing"
)
func TestHash(t *testing.T) {
c := &Cache{}
h := c.NewHash("alice")
h.Write([]byte("hello world"))
sum := fmt.Sprintf("%x", h.Sum())
want := "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
if sum != want {
t.Errorf("hash(hello world) = %v, want %v", sum, want)
}
}
func TestHashFile(t *testing.T) {
f, err := ioutil.TempFile("", "cmd-go-test-")
if err != nil {
t.Fatal(err)
}
name := f.Name()
fmt.Fprintf(f, "hello world")
defer os.Remove(name)
if err := f.Close(); err != nil {
t.Fatal(err)
}
var h ActionID // make sure hash result is assignable to ActionID
h, err = FileHash(name)
if err != nil {
t.Fatal(err)
}
sum := fmt.Sprintf("%x", h)
want := "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
if sum != want {
t.Errorf("hash(hello world) = %v, want %v", sum, want)
}
}
go-tools-2021.1.2/internal/cmd/ 0000775 0000000 0000000 00000000000 14143223131 0016053 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/cmd/ast-to-pattern/ 0000775 0000000 0000000 00000000000 14143223131 0020735 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/cmd/ast-to-pattern/main.go 0000664 0000000 0000000 00000001012 14143223131 0022202 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"go/ast"
"go/token"
"io/ioutil"
"os"
"honnef.co/go/tools/pattern"
)
func main() {
src, err := ioutil.ReadAll(os.Stdin)
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
fset := token.NewFileSet()
node, err := parseDetectingNode(fset, string(src))
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
if _, ok := node.(*ast.File); ok {
fmt.Fprintln(os.Stderr, "cannot convert entire file to Node")
os.Exit(1)
}
fmt.Println(pattern.ASTToNode(node))
}
go-tools-2021.1.2/internal/cmd/ast-to-pattern/parse.go 0000664 0000000 0000000 00000006535 14143223131 0022407 0 ustar 00root root 0000000 0000000 package main
import (
"bytes"
"fmt"
"go/ast"
"go/parser"
"go/scanner"
"go/token"
"text/template"
)
var tmplDecl = template.Must(template.New("").Parse(`` +
`package p; {{ . }}`))
var tmplExprs = template.Must(template.New("").Parse(`` +
`package p; var _ = []interface{}{ {{ . }}, }`))
var tmplStmts = template.Must(template.New("").Parse(`` +
`package p; func _() { {{ . }} }`))
var tmplType = template.Must(template.New("").Parse(`` +
`package p; var _ {{ . }}`))
var tmplValSpec = template.Must(template.New("").Parse(`` +
`package p; var {{ . }}`))
func execTmpl(tmpl *template.Template, src string) string {
var buf bytes.Buffer
if err := tmpl.Execute(&buf, src); err != nil {
panic(err)
}
return buf.String()
}
func noBadNodes(node ast.Node) bool {
any := false
ast.Inspect(node, func(n ast.Node) bool {
if any {
return false
}
switch n.(type) {
case *ast.BadExpr, *ast.BadDecl:
any = true
}
return true
})
return !any
}
func parseType(fset *token.FileSet, src string) (ast.Expr, *ast.File, error) {
asType := execTmpl(tmplType, src)
f, err := parser.ParseFile(fset, "", asType, 0)
if err != nil {
return nil, nil, err
}
vs := f.Decls[0].(*ast.GenDecl).Specs[0].(*ast.ValueSpec)
return vs.Type, f, nil
}
// parseDetectingNode tries its best to parse the ast.Node contained in src, as
// one of: *ast.File, ast.Decl, ast.Expr, ast.Stmt, *ast.ValueSpec.
// It also returns the *ast.File used for the parsing, so that the returned node
// can be easily type-checked.
func parseDetectingNode(fset *token.FileSet, src string) (interface{}, error) {
file := fset.AddFile("", fset.Base(), len(src))
scan := scanner.Scanner{}
scan.Init(file, []byte(src), nil, 0)
if _, tok, _ := scan.Scan(); tok == token.EOF {
return nil, fmt.Errorf("empty source code")
}
var mainErr error
// first try as a whole file
if f, err := parser.ParseFile(fset, "", src, 0); err == nil && noBadNodes(f) {
return f, nil
}
// then as a single declaration, or many
asDecl := execTmpl(tmplDecl, src)
if f, err := parser.ParseFile(fset, "", asDecl, 0); err == nil && noBadNodes(f) {
if len(f.Decls) == 1 {
return f.Decls[0], nil
}
return f, nil
}
// then as value expressions
asExprs := execTmpl(tmplExprs, src)
if f, err := parser.ParseFile(fset, "", asExprs, 0); err == nil && noBadNodes(f) {
vs := f.Decls[0].(*ast.GenDecl).Specs[0].(*ast.ValueSpec)
cl := vs.Values[0].(*ast.CompositeLit)
if len(cl.Elts) == 1 {
return cl.Elts[0], nil
}
return cl.Elts, nil
}
// then try as statements
asStmts := execTmpl(tmplStmts, src)
if f, err := parser.ParseFile(fset, "", asStmts, 0); err == nil && noBadNodes(f) {
bl := f.Decls[0].(*ast.FuncDecl).Body
if len(bl.List) == 1 {
return bl.List[0], nil
}
return bl.List, nil
} else {
// Statements is what covers most cases, so it will give
// the best overall error message. Show positions
// relative to where the user's code is put in the
// template.
mainErr = err
}
// type expressions not yet picked up, for e.g. chans and interfaces
if typ, f, err := parseType(fset, src); err == nil && noBadNodes(f) {
return typ, nil
}
// value specs
asValSpec := execTmpl(tmplValSpec, src)
if f, err := parser.ParseFile(fset, "", asValSpec, 0); err == nil && noBadNodes(f) {
vs := f.Decls[0].(*ast.GenDecl).Specs[0].(*ast.ValueSpec)
return vs, nil
}
return nil, mainErr
}
go-tools-2021.1.2/internal/cmd/gogrep/ 0000775 0000000 0000000 00000000000 14143223131 0017336 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/cmd/gogrep/gogrep.go 0000664 0000000 0000000 00000003025 14143223131 0021150 0 ustar 00root root 0000000 0000000 package main
import (
"flag"
"fmt"
"go/ast"
"go/format"
"go/parser"
"go/token"
"os"
"path/filepath"
"reflect"
"strings"
"honnef.co/go/tools/pattern"
)
func match(fset *token.FileSet, pat pattern.Pattern, f *ast.File) {
ast.Inspect(f, func(node ast.Node) bool {
if node == nil {
return true
}
for _, rel := range pat.Relevant {
if rel == reflect.TypeOf(node) {
m := &pattern.Matcher{}
if m.Match(pat.Root, node) {
fmt.Printf("%s: ", fset.Position(node.Pos()))
format.Node(os.Stdout, fset, node)
fmt.Println()
}
// OPT(dh): we could further speed this up by not
// chasing down impossible subtrees. For example,
// we'll never find an ImportSpec beneath a FuncLit.
return true
}
}
return true
})
}
func main() {
flag.Parse()
// XXX don't use MustParse, handle error
p := &pattern.Parser{}
q, err := p.Parse(flag.Args()[0])
if err != nil {
fmt.Println(err)
os.Exit(1)
}
dir := flag.Args()[1]
// XXX should we create a new fileset per file? what if we're
// checking millions of files, will this use up a lot of memory?
fset := token.NewFileSet()
filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
if err != nil {
// XXX error handling
panic(err)
}
if !strings.HasSuffix(path, ".go") {
return nil
}
// XXX don't try to parse irregular files or directories
f, err := parser.ParseFile(fset, path, nil, parser.ParseComments)
if err != nil {
// XXX log error?
return nil
}
match(fset, q, f)
return nil
})
}
go-tools-2021.1.2/internal/cmd/irdump/ 0000775 0000000 0000000 00000000000 14143223131 0017353 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/cmd/irdump/main.go 0000664 0000000 0000000 00000006027 14143223131 0020633 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.
// irdump: a tool for displaying the IR form of Go programs.
package main
import (
"flag"
"fmt"
"go/build"
"os"
"runtime/pprof"
"honnef.co/go/tools/go/ir"
"honnef.co/go/tools/go/ir/irutil"
"golang.org/x/tools/go/buildutil"
"golang.org/x/tools/go/packages"
)
// flags
var (
mode = ir.BuilderMode(ir.PrintPackages | ir.PrintFunctions)
testFlag = flag.Bool("test", false, "include implicit test packages and executables")
cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")
dot bool
html string
)
func init() {
flag.Var(&mode, "build", ir.BuilderModeDoc)
flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
flag.BoolVar(&dot, "dot", false, "Print Graphviz dot of CFG")
flag.StringVar(&html, "html", "", "Print HTML for 'function'")
}
const usage = `IR builder.
Usage: irdump [-build=[DBCSNFL]] [-test] [-arg=...] package...
Use -help flag to display options.
Examples:
% irdump -build=F hello.go # dump IR form of a single package
% irdump -build=F -test fmt # dump IR form of a package and its tests
`
func main() {
if err := doMain(); err != nil {
fmt.Fprintf(os.Stderr, "irdump: %s\n", err)
os.Exit(1)
}
}
func doMain() error {
flag.Parse()
if len(flag.Args()) == 0 {
fmt.Fprint(os.Stderr, usage)
os.Exit(1)
}
cfg := &packages.Config{
Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles | packages.NeedImports | packages.NeedDeps | packages.NeedTypes | packages.NeedTypesSizes | packages.NeedSyntax | packages.NeedTypesInfo,
Tests: *testFlag,
}
// Profiling support.
if *cpuprofile != "" {
f, err := os.Create(*cpuprofile)
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
// Load, parse and type-check the initial packages.
initial, err := packages.Load(cfg, flag.Args()...)
if err != nil {
return err
}
if len(initial) == 0 {
return fmt.Errorf("no packages")
}
if packages.PrintErrors(initial) > 0 {
return fmt.Errorf("packages contain errors")
}
// Create IR-form program representation.
_, pkgs := irutil.Packages(initial, mode, &irutil.Options{PrintFunc: html})
for i, p := range pkgs {
if p == nil {
return fmt.Errorf("cannot build IR for package %s", initial[i])
}
}
// Build and display only the initial packages
// (and synthetic wrappers).
for _, p := range pkgs {
p.Build()
}
if dot {
for _, p := range pkgs {
for _, m := range p.Members {
if fn, ok := m.(*ir.Function); ok {
fmt.Println("digraph{")
fmt.Printf("label = %q;\n", fn.Name())
for _, b := range fn.Blocks {
fmt.Printf("n%d [label=\"%d: %s\"]\n", b.Index, b.Index, b.Comment)
for _, succ := range b.Succs {
fmt.Printf("n%d -> n%d\n", b.Index, succ.Index)
}
}
fmt.Println("}")
}
}
}
}
return nil
}
go-tools-2021.1.2/internal/go/ 0000775 0000000 0000000 00000000000 14143223131 0015715 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/go/gcimporter/ 0000775 0000000 0000000 00000000000 14143223131 0020070 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/go/gcimporter/UPSTREAM 0000664 0000000 0000000 00000002637 14143223131 0021263 0 ustar 00root root 0000000 0000000 This package is a copy of golang.org/x/tools/go/internal/gcimporter,
imported from commit 33e937220d8f91f1d242ad15aebc3e245aca5515.
We use it to more directly and efficiently load Go packages from export data.
The alternative would be to use golang.org/x/tools/go/gcexportdata.
The following upstream changes have since been incorporated:
655248709eb08403f2cd91d1d0b783f4d5db38d1
35a9159336abb5bc5040b25c5a3ddf1424de1d8d
The following upstream changes have explicitly been skipped:
5c6ccfdb40a2f7d9a602b7f9655dcb7ae91b1938
8e7acdbce89da28e6f7d7c27f67be8cd0abaecd7
7fde01ffd3cdad86ebc5c73c80edd1aeebb255b9
b79f76fe3e9733fa292a2a558160b3658f45f187
35839b7038afa36a6c000733552daa1f5ce1e838
4534fc34de1678d210cdea5130def0ce4aab1835
67e49ef2d0f326051e22a4a55bdf9344ae1a8ed8
5d334387e1e03040456e1bfe650c6d8b036eb467
fa0125251cc482cce8c015000e15beef48ecafa9
a1db63cc08e0021aa688e1531b00ec88fd715898
2363391a5b2fe95c264da3c106a6ecca73490587
The last upstream commit we've looked at was:
35a9159336abb5bc5040b25c5a3ddf1424de1d8d
The following custom changes have been made:
- allow reuse of byte slices in GetExportData
- remove support for old export data formats
- only read type information from archives, skipping object code
- read directly from an os.File when possible, skipping the indirection through a buffered reader
- remove support for writing export data
- use unsafe for a more efficient implementation of (*token.File).SetLines
go-tools-2021.1.2/internal/go/gcimporter/exportdata.go 0000664 0000000 0000000 00000005657 14143223131 0022607 0 ustar 00root root 0000000 0000000 // Copyright 2011 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 copy of $GOROOT/src/go/internal/gcimporter/exportdata.go.
// This file implements FindExportData.
package gcimporter
import (
"bufio"
"fmt"
"io"
"io/ioutil"
"strconv"
"strings"
)
func readGopackHeader(r io.Reader) (name string, size int, err error) {
// See $GOROOT/include/ar.h.
hdr := make([]byte, 16+12+6+6+8+10+2)
_, err = io.ReadFull(r, hdr)
if err != nil {
return
}
// leave for debugging
if false {
fmt.Printf("header: %s", hdr)
}
s := strings.TrimSpace(string(hdr[16+12+6+6+8:][:10]))
size, err = strconv.Atoi(s)
if err != nil || hdr[len(hdr)-2] != '`' || hdr[len(hdr)-1] != '\n' {
err = fmt.Errorf("invalid archive header")
return
}
name = strings.TrimSpace(string(hdr[:16]))
return
}
// findExportData positions the reader r at the beginning of the
// export data section of an underlying GC-created object/archive
// file by reading from it. The reader must be positioned at the
// start of the file before calling this function. The hdr result
// is the string before the export data, either "$$" or "$$B".
//
func findExportData(r *bufio.Reader) (hdr string, length int, err error) {
// Read first line to make sure this is an object file.
line, err := r.ReadSlice('\n')
if err != nil {
err = fmt.Errorf("can't find export data (%v)", err)
return
}
if string(line) == "!\n" {
// Archive file. Scan to __.PKGDEF.
var name string
if name, length, err = readGopackHeader(r); err != nil {
return
}
// First entry should be __.PKGDEF.
if name != "__.PKGDEF" {
err = fmt.Errorf("go archive is missing __.PKGDEF")
return
}
// Read first line of __.PKGDEF data, so that line
// is once again the first line of the input.
if line, err = r.ReadSlice('\n'); err != nil {
err = fmt.Errorf("can't find export data (%v)", err)
return
}
length -= len(line)
}
// Now at __.PKGDEF in archive or still at beginning of file.
// Either way, line should begin with "go object ".
if !strings.HasPrefix(string(line), "go object ") {
err = fmt.Errorf("not a Go object file")
return
}
// Skip over object header to export data.
// Begins after first line starting with $$.
for line[0] != '$' {
if line, err = r.ReadSlice('\n'); err != nil {
err = fmt.Errorf("can't find export data (%v)", err)
return
}
length -= len(line)
}
hdr = string(line)
return
}
func GetExportData(r io.ReadSeeker, b []byte) ([]byte, error) {
br := bufio.NewReader(r)
_, length, err := findExportData(br)
if err != nil {
return nil, err
}
if _, err := r.Seek(-int64(br.Buffered()), io.SeekCurrent); err != nil {
return nil, err
}
if length > 0 {
if cap(b) >= length {
b = b[:length]
} else {
b = make([]byte, length)
}
_, err := io.ReadFull(r, b)
return b, err
} else {
return ioutil.ReadAll(r)
}
}
go-tools-2021.1.2/internal/go/gcimporter/gcimporter.go 0000664 0000000 0000000 00000010722 14143223131 0022574 0 ustar 00root root 0000000 0000000 // Copyright 2011 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 $GOROOT/src/go/internal/gcimporter/gcimporter.go,
// but it also contains the original source-based importer code for Go1.6.
// Once we stop supporting 1.6, we can remove that code.
// Package gcimporter provides various functions for reading
// gc-generated object files that can be used to implement the
// Importer interface defined by the Go 1.5 standard library package.
package gcimporter
import (
"bufio"
"fmt"
"go/build"
"go/token"
"go/types"
"io"
"io/ioutil"
"os"
"path/filepath"
"strings"
)
var pkgExts = [...]string{".a", ".o"}
// FindPkg returns the filename and unique package id for an import
// path based on package information provided by build.Import (using
// the build.Default build.Context). A relative srcDir is interpreted
// relative to the current working directory.
// If no file was found, an empty filename is returned.
//
func FindPkg(path, srcDir string) (filename, id string) {
if path == "" {
return
}
var noext string
switch {
default:
// "x" -> "$GOPATH/pkg/$GOOS_$GOARCH/x.ext", "x"
// Don't require the source files to be present.
if abs, err := filepath.Abs(srcDir); err == nil { // see issue 14282
srcDir = abs
}
bp, _ := build.Import(path, srcDir, build.FindOnly|build.AllowBinary)
if bp.PkgObj == "" {
id = path // make sure we have an id to print in error message
return
}
noext = strings.TrimSuffix(bp.PkgObj, ".a")
id = bp.ImportPath
case build.IsLocalImport(path):
// "./x" -> "/this/directory/x.ext", "/this/directory/x"
noext = filepath.Join(srcDir, path)
id = noext
case filepath.IsAbs(path):
// for completeness only - go/build.Import
// does not support absolute imports
// "/x" -> "/x.ext", "/x"
noext = path
id = path
}
if false { // for debugging
if path != id {
fmt.Printf("%s -> %s\n", path, id)
}
}
// try extensions
for _, ext := range pkgExts {
filename = noext + ext
if f, err := os.Stat(filename); err == nil && !f.IsDir() {
return
}
}
filename = "" // not found
return
}
// Import imports a gc-generated package given its import path and srcDir, adds
// the corresponding package object to the packages map, and returns the object.
// The packages map must contain all packages already imported.
//
func Import(packages map[string]*types.Package, path, srcDir string, lookup func(path string) (io.ReadCloser, error)) (pkg *types.Package, err error) {
var rc io.ReadCloser
var filename, id string
if lookup != nil {
// With custom lookup specified, assume that caller has
// converted path to a canonical import path for use in the map.
if path == "unsafe" {
return types.Unsafe, nil
}
id = path
// No need to re-import if the package was imported completely before.
if pkg = packages[id]; pkg != nil && pkg.Complete() {
return
}
f, err := lookup(path)
if err != nil {
return nil, err
}
rc = f
} else {
filename, id = FindPkg(path, srcDir)
if filename == "" {
if path == "unsafe" {
return types.Unsafe, nil
}
return nil, fmt.Errorf("can't find import: %q", id)
}
// no need to re-import if the package was imported completely before
if pkg = packages[id]; pkg != nil && pkg.Complete() {
return
}
// open file
f, err := os.Open(filename)
if err != nil {
return nil, err
}
defer func() {
if err != nil {
// add file name to error
err = fmt.Errorf("%s: %v", filename, err)
}
}()
rc = f
}
defer rc.Close()
var hdr string
buf := bufio.NewReader(rc)
if hdr, _, err = findExportData(buf); err != nil {
return
}
switch hdr {
case "$$B\n":
var data []byte
data, err = ioutil.ReadAll(buf)
if err != nil {
break
}
// TODO(gri): allow clients of go/importer to provide a FileSet.
// Or, define a new standard go/types/gcexportdata package.
fset := token.NewFileSet()
// The indexed export format starts with an 'i'.
if len(data) == 0 || data[0] != 'i' {
return nil, fmt.Errorf("unknown export data format %c", data[0])
}
_, pkg, err = IImportData(fset, packages, data[1:], id)
default:
err = fmt.Errorf("unknown export data header: %q", hdr)
}
return
}
type byPath []*types.Package
func (a byPath) Len() int { return len(a) }
func (a byPath) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a byPath) Less(i, j int) bool { return a[i].Path() < a[j].Path() }
go-tools-2021.1.2/internal/go/gcimporter/gcimporter11_test.go 0000664 0000000 0000000 00000011563 14143223131 0024001 0 ustar 00root root 0000000 0000000 // 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.
// +build go1.11
package gcimporter
import (
"go/constant"
"go/types"
"runtime"
"strings"
"testing"
)
var importedObjectTests = []struct {
name string
want string
}{
// non-interfaces
{"crypto.Hash", "type Hash uint"},
{"go/ast.ObjKind", "type ObjKind int"},
{"go/types.Qualifier", "type Qualifier func(*Package) string"},
{"go/types.Comparable", "func Comparable(T Type) bool"},
{"math.Pi", "const Pi untyped float"},
{"math.Sin", "func Sin(x float64) float64"},
{"go/ast.NotNilFilter", "func NotNilFilter(_ string, v reflect.Value) bool"},
{"go/internal/gcimporter.FindPkg", "func FindPkg(path string, srcDir string) (filename string, id string)"},
// interfaces
{"context.Context", "type Context interface{Deadline() (deadline time.Time, ok bool); Done() <-chan struct{}; Err() error; Value(key interface{}) interface{}}"},
{"crypto.Decrypter", "type Decrypter interface{Decrypt(rand io.Reader, msg []byte, opts DecrypterOpts) (plaintext []byte, err error); Public() PublicKey}"},
{"encoding.BinaryMarshaler", "type BinaryMarshaler interface{MarshalBinary() (data []byte, err error)}"},
{"io.Reader", "type Reader interface{Read(p []byte) (n int, err error)}"},
{"io.ReadWriter", "type ReadWriter interface{Reader; Writer}"},
{"go/ast.Node", "type Node interface{End() go/token.Pos; Pos() go/token.Pos}"},
{"go/types.Type", "type Type interface{String() string; Underlying() Type}"},
}
func TestImportedTypes(t *testing.T) {
skipSpecialPlatforms(t)
// This package only handles gc export data.
if runtime.Compiler != "gc" {
t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
}
for _, test := range importedObjectTests {
obj := importObject(t, test.name)
if obj == nil {
continue // error reported elsewhere
}
got := types.ObjectString(obj, types.RelativeTo(obj.Pkg()))
if got != test.want {
t.Errorf("%s: got %q; want %q", test.name, got, test.want)
}
if named, _ := obj.Type().(*types.Named); named != nil {
verifyInterfaceMethodRecvs(t, named, 0)
}
}
}
func TestImportedConsts(t *testing.T) {
skipSpecialPlatforms(t)
tests := []struct {
name string
want constant.Kind
}{
{"math.Pi", constant.Float},
{"math.MaxFloat64", constant.Float},
{"math.MaxInt64", constant.Int},
}
for _, test := range tests {
obj := importObject(t, test.name)
if got := obj.(*types.Const).Val().Kind(); got != test.want {
t.Errorf("%s: imported as constant.Kind(%v), want constant.Kind(%v)", test.name, got, test.want)
}
}
}
// importObject imports the object specified by a name of the form
// ., e.g. go/types.Type.
//
// If any errors occur they are reported via t and the resulting object will
// be nil.
func importObject(t *testing.T, name string) types.Object {
s := strings.Split(name, ".")
if len(s) != 2 {
t.Fatal("inconsistent test data")
}
importPath := s[0]
objName := s[1]
pkg, err := Import(make(map[string]*types.Package), importPath, ".", nil)
if err != nil {
t.Error(err)
return nil
}
obj := pkg.Scope().Lookup(objName)
if obj == nil {
t.Errorf("%s: object not found", name)
return nil
}
return obj
}
// verifyInterfaceMethodRecvs verifies that method receiver types
// are named if the methods belong to a named interface type.
func verifyInterfaceMethodRecvs(t *testing.T, named *types.Named, level int) {
// avoid endless recursion in case of an embedding bug that lead to a cycle
if level > 10 {
t.Errorf("%s: embeds itself", named)
return
}
iface, _ := named.Underlying().(*types.Interface)
if iface == nil {
return // not an interface
}
// check explicitly declared methods
for i := 0; i < iface.NumExplicitMethods(); i++ {
m := iface.ExplicitMethod(i)
recv := m.Type().(*types.Signature).Recv()
if recv == nil {
t.Errorf("%s: missing receiver type", m)
continue
}
if recv.Type() != named {
t.Errorf("%s: got recv type %s; want %s", m, recv.Type(), named)
}
}
// check embedded interfaces (if they are named, too)
for i := 0; i < iface.NumEmbeddeds(); i++ {
// embedding of interfaces cannot have cycles; recursion will terminate
if etype, _ := iface.EmbeddedType(i).(*types.Named); etype != nil {
verifyInterfaceMethodRecvs(t, etype, level+1)
}
}
}
func TestIssue25301(t *testing.T) {
skipSpecialPlatforms(t)
// This package only handles gc export data.
if runtime.Compiler != "gc" {
t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
}
// On windows, we have to set the -D option for the compiler to avoid having a drive
// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
if runtime.GOOS == "windows" {
t.Skip("avoid dealing with relative paths/drive letters on windows")
}
compileAndImportPkg(t, "issue25301")
}
go-tools-2021.1.2/internal/go/gcimporter/gcimporter_test.go 0000664 0000000 0000000 00000036732 14143223131 0023644 0 ustar 00root root 0000000 0000000 // Copyright 2011 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 copy of $GOROOT/src/go/internal/gcimporter/gcimporter_test.go,
// adjusted to make it build with code from (std lib) internal/testenv copied.
package gcimporter
import (
"bytes"
"fmt"
"go/types"
"io/ioutil"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"testing"
"time"
"honnef.co/go/tools/internal/testenv"
)
func TestMain(m *testing.M) {
testenv.ExitIfSmallMachine()
os.Exit(m.Run())
}
// ----------------------------------------------------------------------------
// The following three functions (Builder, HasGoBuild, MustHaveGoBuild) were
// copied from $GOROOT/src/internal/testenv since that package is not available
// in x/tools.
// Builder reports the name of the builder running this test
// (for example, "linux-amd64" or "windows-386-gce").
// If the test is not running on the build infrastructure,
// Builder returns the empty string.
func Builder() string {
return os.Getenv("GO_BUILDER_NAME")
}
// HasGoBuild reports whether the current system can build programs with ``go build''
// and then run them with os.StartProcess or exec.Command.
func HasGoBuild() bool {
switch runtime.GOOS {
case "android", "nacl":
return false
case "darwin":
if strings.HasPrefix(runtime.GOARCH, "arm") {
return false
}
}
return true
}
// MustHaveGoBuild checks that the current system can build programs with ``go build''
// and then run them with os.StartProcess or exec.Command.
// If not, MustHaveGoBuild calls t.Skip with an explanation.
func MustHaveGoBuild(t *testing.T) {
testenv.NeedsTool(t, "go")
if !HasGoBuild() {
t.Skipf("skipping test: 'go build' not available on %s/%s", runtime.GOOS, runtime.GOARCH)
}
}
// ----------------------------------------------------------------------------
// skipSpecialPlatforms causes the test to be skipped for platforms where
// builders (build.golang.org) don't have access to compiled packages for
// import.
func skipSpecialPlatforms(t *testing.T) {
switch platform := runtime.GOOS + "-" + runtime.GOARCH; platform {
case "nacl-amd64p32",
"nacl-386",
"nacl-arm",
"darwin-arm",
"darwin-arm64":
t.Skipf("no compiled packages available for import on %s", platform)
}
}
// compile runs the compiler on filename, with dirname as the working directory,
// and writes the output file to outdirname.
func compile(t *testing.T, dirname, filename, outdirname string) string {
/* testenv. */ MustHaveGoBuild(t)
// filename must end with ".go"
if !strings.HasSuffix(filename, ".go") {
t.Fatalf("filename doesn't end in .go: %s", filename)
}
basename := filepath.Base(filename)
outname := filepath.Join(outdirname, basename[:len(basename)-2]+"o")
cmd := exec.Command("go", "tool", "compile", "-o", outname, filename)
cmd.Dir = dirname
out, err := cmd.CombinedOutput()
if err != nil {
t.Logf("%s", out)
t.Fatalf("go tool compile %s failed: %s", filename, err)
}
return outname
}
func testPath(t *testing.T, path, srcDir string) *types.Package {
t0 := time.Now()
pkg, err := Import(make(map[string]*types.Package), path, srcDir, nil)
if err != nil {
t.Errorf("testPath(%s): %s", path, err)
return nil
}
t.Logf("testPath(%s): %v", path, time.Since(t0))
return pkg
}
const maxTime = 30 * time.Second
func testDir(t *testing.T, dir string, endTime time.Time) (nimports int) {
dirname := filepath.Join(runtime.GOROOT(), "pkg", runtime.GOOS+"_"+runtime.GOARCH, dir)
list, err := ioutil.ReadDir(dirname)
if err != nil {
t.Fatalf("testDir(%s): %s", dirname, err)
}
for _, f := range list {
if time.Now().After(endTime) {
t.Log("testing time used up")
return
}
switch {
case !f.IsDir():
// try extensions
for _, ext := range pkgExts {
if strings.HasSuffix(f.Name(), ext) {
name := f.Name()[0 : len(f.Name())-len(ext)] // remove extension
if testPath(t, filepath.Join(dir, name), dir) != nil {
nimports++
}
}
}
case f.IsDir():
nimports += testDir(t, filepath.Join(dir, f.Name()), endTime)
}
}
return
}
func mktmpdir(t *testing.T) string {
tmpdir, err := ioutil.TempDir("", "gcimporter_test")
if err != nil {
t.Fatal("mktmpdir:", err)
}
if err := os.Mkdir(filepath.Join(tmpdir, "testdata"), 0700); err != nil {
os.RemoveAll(tmpdir)
t.Fatal("mktmpdir:", err)
}
return tmpdir
}
const testfile = "exports.go"
func TestImportTestdata(t *testing.T) {
// This package only handles gc export data.
if runtime.Compiler != "gc" {
t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
}
tmpdir := mktmpdir(t)
defer os.RemoveAll(tmpdir)
compile(t, "testdata", testfile, filepath.Join(tmpdir, "testdata"))
// filename should end with ".go"
filename := testfile[:len(testfile)-3]
if pkg := testPath(t, "./testdata/"+filename, tmpdir); pkg != nil {
// The package's Imports list must include all packages
// explicitly imported by testfile, plus all packages
// referenced indirectly via exported objects in testfile.
// With the textual export format (when run against Go1.6),
// the list may also include additional packages that are
// not strictly required for import processing alone (they
// are exported to err "on the safe side").
// For now, we just test the presence of a few packages
// that we know are there for sure.
got := fmt.Sprint(pkg.Imports())
for _, want := range []string{"go/ast", "go/token"} {
if !strings.Contains(got, want) {
t.Errorf(`Package("exports").Imports() = %s, does not contain %s`, got, want)
}
}
}
}
func TestVersionHandling(t *testing.T) {
skipSpecialPlatforms(t) // we really only need to exclude nacl platforms, but this is fine
// This package only handles gc export data.
if runtime.Compiler != "gc" {
t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
}
const dir = "./testdata/versions"
list, err := ioutil.ReadDir(dir)
if err != nil {
t.Fatal(err)
}
tmpdir := mktmpdir(t)
defer os.RemoveAll(tmpdir)
corruptdir := filepath.Join(tmpdir, "testdata", "versions")
if err := os.Mkdir(corruptdir, 0700); err != nil {
t.Fatal(err)
}
for _, f := range list {
name := f.Name()
if !strings.HasSuffix(name, ".a") {
continue // not a package file
}
if strings.Contains(name, "corrupted") {
continue // don't process a leftover corrupted file
}
pkgpath := "./" + name[:len(name)-2]
if testing.Verbose() {
t.Logf("importing %s", name)
}
// test that export data can be imported
_, err := Import(make(map[string]*types.Package), pkgpath, dir, nil)
if err != nil {
// ok to fail if it fails with a newer version error for select files
if strings.Contains(err.Error(), "newer version") {
switch name {
case "test_go1.11_999b.a", "test_go1.11_999i.a":
continue
}
// fall through
}
t.Errorf("import %q failed: %v", pkgpath, err)
continue
}
// create file with corrupted export data
// 1) read file
data, err := ioutil.ReadFile(filepath.Join(dir, name))
if err != nil {
t.Fatal(err)
}
// 2) find export data
i := bytes.Index(data, []byte("\n$$B\n")) + 5
j := bytes.Index(data[i:], []byte("\n$$\n")) + i
if i < 0 || j < 0 || i > j {
t.Fatalf("export data section not found (i = %d, j = %d)", i, j)
}
// 3) corrupt the data (increment every 7th byte)
for k := j - 13; k >= i; k -= 7 {
data[k]++
}
// 4) write the file
pkgpath += "_corrupted"
filename := filepath.Join(corruptdir, pkgpath) + ".a"
ioutil.WriteFile(filename, data, 0666)
// test that importing the corrupted file results in an error
_, err = Import(make(map[string]*types.Package), pkgpath, corruptdir, nil)
if err == nil {
t.Errorf("import corrupted %q succeeded", pkgpath)
} else if msg := err.Error(); !strings.Contains(msg, "version skew") {
t.Errorf("import %q error incorrect (%s)", pkgpath, msg)
}
}
}
func TestImportStdLib(t *testing.T) {
skipSpecialPlatforms(t)
// This package only handles gc export data.
if runtime.Compiler != "gc" {
t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
}
dt := maxTime
if testing.Short() && /* testenv. */ Builder() == "" {
dt = 10 * time.Millisecond
}
nimports := testDir(t, "", time.Now().Add(dt)) // installed packages
t.Logf("tested %d imports", nimports)
}
func TestIssue5815(t *testing.T) {
skipSpecialPlatforms(t)
// This package only handles gc export data.
if runtime.Compiler != "gc" {
t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
}
pkg := importPkg(t, "strings", ".")
scope := pkg.Scope()
for _, name := range scope.Names() {
obj := scope.Lookup(name)
if obj.Pkg() == nil {
t.Errorf("no pkg for %s", obj)
}
if tname, _ := obj.(*types.TypeName); tname != nil {
named := tname.Type().(*types.Named)
for i := 0; i < named.NumMethods(); i++ {
m := named.Method(i)
if m.Pkg() == nil {
t.Errorf("no pkg for %s", m)
}
}
}
}
}
// Smoke test to ensure that imported methods get the correct package.
func TestCorrectMethodPackage(t *testing.T) {
skipSpecialPlatforms(t)
// This package only handles gc export data.
if runtime.Compiler != "gc" {
t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
}
imports := make(map[string]*types.Package)
_, err := Import(imports, "net/http", ".", nil)
if err != nil {
t.Fatal(err)
}
mutex := imports["sync"].Scope().Lookup("Mutex").(*types.TypeName).Type()
mset := types.NewMethodSet(types.NewPointer(mutex)) // methods of *sync.Mutex
sel := mset.Lookup(nil, "Lock")
lock := sel.Obj().(*types.Func)
if got, want := lock.Pkg().Path(), "sync"; got != want {
t.Errorf("got package path %q; want %q", got, want)
}
}
func TestIssue13566(t *testing.T) {
skipSpecialPlatforms(t)
// This package only handles gc export data.
if runtime.Compiler != "gc" {
t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
}
// On windows, we have to set the -D option for the compiler to avoid having a drive
// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
if runtime.GOOS == "windows" {
t.Skip("avoid dealing with relative paths/drive letters on windows")
}
tmpdir := mktmpdir(t)
defer os.RemoveAll(tmpdir)
testoutdir := filepath.Join(tmpdir, "testdata")
// b.go needs to be compiled from the output directory so that the compiler can
// find the compiled package a. We pass the full path to compile() so that we
// don't have to copy the file to that directory.
bpath, err := filepath.Abs(filepath.Join("testdata", "b.go"))
if err != nil {
t.Fatal(err)
}
compile(t, "testdata", "a.go", testoutdir)
compile(t, testoutdir, bpath, testoutdir)
// import must succeed (test for issue at hand)
pkg := importPkg(t, "./testdata/b", tmpdir)
// make sure all indirectly imported packages have names
for _, imp := range pkg.Imports() {
if imp.Name() == "" {
t.Errorf("no name for %s package", imp.Path())
}
}
}
func TestIssue13898(t *testing.T) {
skipSpecialPlatforms(t)
// This package only handles gc export data.
if runtime.Compiler != "gc" {
t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
}
// import go/internal/gcimporter which imports go/types partially
imports := make(map[string]*types.Package)
_, err := Import(imports, "go/internal/gcimporter", ".", nil)
if err != nil {
t.Fatal(err)
}
// look for go/types package
var goTypesPkg *types.Package
for path, pkg := range imports {
if path == "go/types" {
goTypesPkg = pkg
break
}
}
if goTypesPkg == nil {
t.Fatal("go/types not found")
}
// look for go/types.Object type
obj := lookupObj(t, goTypesPkg.Scope(), "Object")
typ, ok := obj.Type().(*types.Named)
if !ok {
t.Fatalf("go/types.Object type is %v; wanted named type", typ)
}
// lookup go/types.Object.Pkg method
m, index, indirect := types.LookupFieldOrMethod(typ, false, nil, "Pkg")
if m == nil {
t.Fatalf("go/types.Object.Pkg not found (index = %v, indirect = %v)", index, indirect)
}
// the method must belong to go/types
if m.Pkg().Path() != "go/types" {
t.Fatalf("found %v; want go/types", m.Pkg())
}
}
func TestIssue15517(t *testing.T) {
skipSpecialPlatforms(t)
// This package only handles gc export data.
if runtime.Compiler != "gc" {
t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
}
// On windows, we have to set the -D option for the compiler to avoid having a drive
// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
if runtime.GOOS == "windows" {
t.Skip("avoid dealing with relative paths/drive letters on windows")
}
tmpdir := mktmpdir(t)
defer os.RemoveAll(tmpdir)
compile(t, "testdata", "p.go", filepath.Join(tmpdir, "testdata"))
// Multiple imports of p must succeed without redeclaration errors.
// We use an import path that's not cleaned up so that the eventual
// file path for the package is different from the package path; this
// will expose the error if it is present.
//
// (Issue: Both the textual and the binary importer used the file path
// of the package to be imported as key into the shared packages map.
// However, the binary importer then used the package path to identify
// the imported package to mark it as complete; effectively marking the
// wrong package as complete. By using an "unclean" package path, the
// file and package path are different, exposing the problem if present.
// The same issue occurs with vendoring.)
imports := make(map[string]*types.Package)
for i := 0; i < 3; i++ {
if _, err := Import(imports, "./././testdata/p", tmpdir, nil); err != nil {
t.Fatal(err)
}
}
}
func TestIssue15920(t *testing.T) {
skipSpecialPlatforms(t)
// This package only handles gc export data.
if runtime.Compiler != "gc" {
t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
}
// On windows, we have to set the -D option for the compiler to avoid having a drive
// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
if runtime.GOOS == "windows" {
t.Skip("avoid dealing with relative paths/drive letters on windows")
}
compileAndImportPkg(t, "issue15920")
}
func TestIssue20046(t *testing.T) {
skipSpecialPlatforms(t)
// This package only handles gc export data.
if runtime.Compiler != "gc" {
t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
}
// On windows, we have to set the -D option for the compiler to avoid having a drive
// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
if runtime.GOOS == "windows" {
t.Skip("avoid dealing with relative paths/drive letters on windows")
}
// "./issue20046".V.M must exist
pkg := compileAndImportPkg(t, "issue20046")
obj := lookupObj(t, pkg.Scope(), "V")
if m, index, indirect := types.LookupFieldOrMethod(obj.Type(), false, nil, "M"); m == nil {
t.Fatalf("V.M not found (index = %v, indirect = %v)", index, indirect)
}
}
func importPkg(t *testing.T, path, srcDir string) *types.Package {
pkg, err := Import(make(map[string]*types.Package), path, srcDir, nil)
if err != nil {
t.Fatal(err)
}
return pkg
}
func compileAndImportPkg(t *testing.T, name string) *types.Package {
tmpdir := mktmpdir(t)
defer os.RemoveAll(tmpdir)
compile(t, "testdata", name+".go", filepath.Join(tmpdir, "testdata"))
return importPkg(t, "./testdata/"+name, tmpdir)
}
func lookupObj(t *testing.T, scope *types.Scope, name string) types.Object {
if obj := scope.Lookup(name); obj != nil {
return obj
}
t.Fatalf("%s not found", name)
return nil
}
go-tools-2021.1.2/internal/go/gcimporter/iimport.go 0000664 0000000 0000000 00000041373 14143223131 0022112 0 ustar 00root root 0000000 0000000 // 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.
// Indexed package import.
// See cmd/compile/internal/gc/iexport.go for the export data format.
// This file is a copy of $GOROOT/src/go/internal/gcimporter/iimport.go.
package gcimporter
import (
"bytes"
"encoding/binary"
"fmt"
"go/constant"
"go/token"
"go/types"
"io"
"sort"
"sync"
"unsafe"
)
type intReader struct {
*bytes.Reader
path string
}
func errorf(format string, args ...interface{}) {
panic(fmt.Sprintf(format, args...))
}
func (r *intReader) uint64() uint64 {
i, err := binary.ReadUvarint(r.Reader)
if err != nil {
errorf("import %q: read varint error: %v", r.path, err)
}
return i
}
const predeclReserved = 32
type itag uint64
const (
// Types
definedType itag = iota
pointerType
sliceType
arrayType
chanType
mapType
signatureType
structType
interfaceType
)
// IImportData imports a package from the serialized package data
// and returns the number of bytes consumed and a reference to the package.
// If the export data version is not recognized or the format is otherwise
// compromised, an error is returned.
func IImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (_ int, pkg *types.Package, err error) {
const currentVersion = 1
version := int64(-1)
defer func() {
if e := recover(); e != nil {
if version > currentVersion {
err = fmt.Errorf("cannot import %q (%v), export data is newer version - update tool", path, e)
} else {
err = fmt.Errorf("cannot import %q (%v), possibly version skew - reinstall package", path, e)
}
}
}()
// OPT(dh): use a cheaper reader that does less state tracking. we
// don't need to be able to unread.
r := &intReader{bytes.NewReader(data), path}
version = int64(r.uint64())
switch version {
case currentVersion, 0:
default:
errorf("unknown iexport format version %d", version)
}
sLen := int64(r.uint64())
dLen := int64(r.uint64())
whence, _ := r.Seek(0, io.SeekCurrent)
stringData := data[whence : whence+sLen]
declData := data[whence+sLen : whence+sLen+dLen]
r.Seek(sLen+dLen, io.SeekCurrent)
p := iimporter{
ipath: path,
version: int(version),
stringData: stringData,
stringCache: make(map[uint64]string),
pkgCache: make(map[uint64]*types.Package),
declData: declData,
pkgIndex: make(map[*types.Package]map[string]uint64),
typCache: make(map[uint64]types.Type),
fake: fakeFileSet{
fset: fset,
files: make(map[string]*token.File),
},
}
for i, pt := range predeclared() {
p.typCache[uint64(i)] = pt
}
pkgList := make([]*types.Package, r.uint64())
for i := range pkgList {
pkgPathOff := r.uint64()
pkgPath := p.stringAt(pkgPathOff)
pkgName := p.stringAt(r.uint64())
_ = r.uint64() // package height; unused by go/types
if pkgPath == "" {
pkgPath = path
}
pkg := imports[pkgPath]
if pkg == nil {
pkg = types.NewPackage(pkgPath, pkgName)
imports[pkgPath] = pkg
} else if pkg.Name() != pkgName {
errorf("conflicting names %s and %s for package %q", pkg.Name(), pkgName, path)
}
p.pkgCache[pkgPathOff] = pkg
nameIndex := make(map[string]uint64)
for nSyms := r.uint64(); nSyms > 0; nSyms-- {
name := p.stringAt(r.uint64())
nameIndex[name] = r.uint64()
}
p.pkgIndex[pkg] = nameIndex
pkgList[i] = pkg
}
if len(pkgList) == 0 {
errorf("no packages found for %s", path)
panic("unreachable")
}
p.ipkg = pkgList[0]
names := make([]string, 0, len(p.pkgIndex[p.ipkg]))
for name := range p.pkgIndex[p.ipkg] {
names = append(names, name)
}
sort.Strings(names)
for _, name := range names {
p.doDecl(p.ipkg, name)
}
for _, typ := range p.interfaceList {
typ.Complete()
}
// record all referenced packages as imports
list := append(([]*types.Package)(nil), pkgList[1:]...)
sort.Sort(byPath(list))
p.ipkg.SetImports(list)
// package was imported completely and without errors
p.ipkg.MarkComplete()
consumed, _ := r.Seek(0, io.SeekCurrent)
return int(consumed), p.ipkg, nil
}
type iimporter struct {
ipath string
ipkg *types.Package
version int
stringData []byte
stringCache map[uint64]string
pkgCache map[uint64]*types.Package
declData []byte
pkgIndex map[*types.Package]map[string]uint64
typCache map[uint64]types.Type
fake fakeFileSet
interfaceList []*types.Interface
}
func (p *iimporter) doDecl(pkg *types.Package, name string) {
// See if we've already imported this declaration.
if obj := pkg.Scope().Lookup(name); obj != nil {
return
}
off, ok := p.pkgIndex[pkg][name]
if !ok {
errorf("%v.%v not in index", pkg, name)
}
r := &importReader{p: p, currPkg: pkg}
r.declReader.Reset(p.declData[off:])
r.obj(name)
}
func (p *iimporter) stringAt(off uint64) string {
if s, ok := p.stringCache[off]; ok {
return s
}
slen, n := binary.Uvarint(p.stringData[off:])
if n <= 0 {
errorf("varint failed")
}
spos := off + uint64(n)
s := string(p.stringData[spos : spos+slen])
p.stringCache[off] = s
return s
}
func (p *iimporter) pkgAt(off uint64) *types.Package {
if pkg, ok := p.pkgCache[off]; ok {
return pkg
}
path := p.stringAt(off)
if path == p.ipath {
return p.ipkg
}
errorf("missing package %q in %q", path, p.ipath)
return nil
}
func (p *iimporter) typAt(off uint64, base *types.Named) types.Type {
if t, ok := p.typCache[off]; ok && (base == nil || !isInterface(t)) {
return t
}
if off < predeclReserved {
errorf("predeclared type missing from cache: %v", off)
}
r := &importReader{p: p}
r.declReader.Reset(p.declData[off-predeclReserved:])
t := r.doType(base)
if base == nil || !isInterface(t) {
p.typCache[off] = t
}
return t
}
type importReader struct {
p *iimporter
declReader bytes.Reader
currPkg *types.Package
prevFile string
prevLine int64
prevColumn int64
}
func (r *importReader) obj(name string) {
tag := r.byte()
pos := r.pos()
switch tag {
case 'A':
typ := r.typ()
r.declare(types.NewTypeName(pos, r.currPkg, name, typ))
case 'C':
typ, val := r.value()
r.declare(types.NewConst(pos, r.currPkg, name, typ, val))
case 'F':
sig := r.signature(nil)
r.declare(types.NewFunc(pos, r.currPkg, name, sig))
case 'T':
// Types can be recursive. We need to setup a stub
// declaration before recursing.
obj := types.NewTypeName(pos, r.currPkg, name, nil)
named := types.NewNamed(obj, nil, nil)
r.declare(obj)
underlying := r.p.typAt(r.uint64(), named).Underlying()
named.SetUnderlying(underlying)
if !isInterface(underlying) {
for n := r.uint64(); n > 0; n-- {
mpos := r.pos()
mname := r.ident()
recv := r.param()
msig := r.signature(recv)
named.AddMethod(types.NewFunc(mpos, r.currPkg, mname, msig))
}
}
case 'V':
typ := r.typ()
r.declare(types.NewVar(pos, r.currPkg, name, typ))
default:
errorf("unexpected tag: %v", tag)
}
}
func (r *importReader) declare(obj types.Object) {
obj.Pkg().Scope().Insert(obj)
}
func (r *importReader) value() (typ types.Type, val constant.Value) {
typ = r.typ()
switch b := typ.Underlying().(*types.Basic); b.Info() & types.IsConstType {
case types.IsBoolean:
val = constant.MakeBool(r.bool())
case types.IsString:
val = constant.MakeString(r.string())
case types.IsInteger:
val = r.mpint(b)
case types.IsFloat:
val = r.mpfloat(b)
case types.IsComplex:
re := r.mpfloat(b)
im := r.mpfloat(b)
val = constant.BinaryOp(re, token.ADD, constant.MakeImag(im))
default:
if b.Kind() == types.Invalid {
val = constant.MakeUnknown()
return
}
errorf("unexpected type %v", typ) // panics
panic("unreachable")
}
return
}
func intSize(b *types.Basic) (signed bool, maxBytes uint) {
if (b.Info() & types.IsUntyped) != 0 {
return true, 64
}
switch b.Kind() {
case types.Float32, types.Complex64:
return true, 3
case types.Float64, types.Complex128:
return true, 7
}
signed = (b.Info() & types.IsUnsigned) == 0
switch b.Kind() {
case types.Int8, types.Uint8:
maxBytes = 1
case types.Int16, types.Uint16:
maxBytes = 2
case types.Int32, types.Uint32:
maxBytes = 4
default:
maxBytes = 8
}
return
}
func (r *importReader) mpint(b *types.Basic) constant.Value {
signed, maxBytes := intSize(b)
maxSmall := 256 - maxBytes
if signed {
maxSmall = 256 - 2*maxBytes
}
if maxBytes == 1 {
maxSmall = 256
}
n, _ := r.declReader.ReadByte()
if uint(n) < maxSmall {
v := int64(n)
if signed {
v >>= 1
if n&1 != 0 {
v = ^v
}
}
return constant.MakeInt64(v)
}
v := -n
if signed {
v = -(n &^ 1) >> 1
}
if v < 1 || uint(v) > maxBytes {
errorf("weird decoding: %v, %v => %v", n, signed, v)
}
buf := make([]byte, v)
io.ReadFull(&r.declReader, buf)
// convert to little endian
// TODO(gri) go/constant should have a more direct conversion function
// (e.g., once it supports a big.Float based implementation)
for i, j := 0, len(buf)-1; i < j; i, j = i+1, j-1 {
buf[i], buf[j] = buf[j], buf[i]
}
x := constant.MakeFromBytes(buf)
if signed && n&1 != 0 {
x = constant.UnaryOp(token.SUB, x, 0)
}
return x
}
func (r *importReader) mpfloat(b *types.Basic) constant.Value {
x := r.mpint(b)
if constant.Sign(x) == 0 {
return x
}
exp := r.int64()
switch {
case exp > 0:
x = constant.Shift(x, token.SHL, uint(exp))
// Ensure that the imported Kind is Float, else this constant may run into
// bitsize limits on overlarge integers. Eventually we can instead adopt
// the approach of CL 288632, but that CL relies on go/constant APIs that
// were introduced in go1.13.
//
// TODO(rFindley): sync the logic here with tip Go once we no longer
// support go1.12.
x = constant.ToFloat(x)
case exp < 0:
d := constant.Shift(constant.MakeInt64(1), token.SHL, uint(-exp))
x = constant.BinaryOp(x, token.QUO, d)
}
return x
}
func (r *importReader) ident() string {
return r.string()
}
func (r *importReader) qualifiedIdent() (*types.Package, string) {
name := r.string()
pkg := r.pkg()
return pkg, name
}
func (r *importReader) pos() token.Pos {
if r.p.version >= 1 {
r.posv1()
} else {
r.posv0()
}
if r.prevFile == "" && r.prevLine == 0 && r.prevColumn == 0 {
return token.NoPos
}
return r.p.fake.pos(r.prevFile, int(r.prevLine), int(r.prevColumn))
}
func (r *importReader) posv0() {
delta := r.int64()
if delta != deltaNewFile {
r.prevLine += delta
} else if l := r.int64(); l == -1 {
r.prevLine += deltaNewFile
} else {
r.prevFile = r.string()
r.prevLine = l
}
}
func (r *importReader) posv1() {
delta := r.int64()
r.prevColumn += delta >> 1
if delta&1 != 0 {
delta = r.int64()
r.prevLine += delta >> 1
if delta&1 != 0 {
r.prevFile = r.string()
}
}
}
func (r *importReader) typ() types.Type {
return r.p.typAt(r.uint64(), nil)
}
func isInterface(t types.Type) bool {
_, ok := t.(*types.Interface)
return ok
}
func (r *importReader) pkg() *types.Package { return r.p.pkgAt(r.uint64()) }
func (r *importReader) string() string { return r.p.stringAt(r.uint64()) }
func (r *importReader) doType(base *types.Named) types.Type {
switch k := r.kind(); k {
default:
errorf("unexpected kind tag in %q: %v", r.p.ipath, k)
return nil
case definedType:
pkg, name := r.qualifiedIdent()
r.p.doDecl(pkg, name)
return pkg.Scope().Lookup(name).(*types.TypeName).Type()
case pointerType:
return types.NewPointer(r.typ())
case sliceType:
return types.NewSlice(r.typ())
case arrayType:
n := r.uint64()
return types.NewArray(r.typ(), int64(n))
case chanType:
dir := chanDir(int(r.uint64()))
return types.NewChan(dir, r.typ())
case mapType:
return types.NewMap(r.typ(), r.typ())
case signatureType:
r.currPkg = r.pkg()
return r.signature(nil)
case structType:
r.currPkg = r.pkg()
fields := make([]*types.Var, r.uint64())
tags := make([]string, len(fields))
for i := range fields {
fpos := r.pos()
fname := r.ident()
ftyp := r.typ()
emb := r.bool()
tag := r.string()
fields[i] = types.NewField(fpos, r.currPkg, fname, ftyp, emb)
tags[i] = tag
}
return types.NewStruct(fields, tags)
case interfaceType:
r.currPkg = r.pkg()
embeddeds := make([]types.Type, r.uint64())
for i := range embeddeds {
_ = r.pos()
embeddeds[i] = r.typ()
}
methods := make([]*types.Func, r.uint64())
for i := range methods {
mpos := r.pos()
mname := r.ident()
// TODO(mdempsky): Matches bimport.go, but I
// don't agree with this.
var recv *types.Var
if base != nil {
recv = types.NewVar(token.NoPos, r.currPkg, "", base)
}
msig := r.signature(recv)
methods[i] = types.NewFunc(mpos, r.currPkg, mname, msig)
}
typ := newInterface(methods, embeddeds)
r.p.interfaceList = append(r.p.interfaceList, typ)
return typ
}
}
func (r *importReader) kind() itag {
return itag(r.uint64())
}
func (r *importReader) signature(recv *types.Var) *types.Signature {
params := r.paramList()
results := r.paramList()
variadic := params.Len() > 0 && r.bool()
return types.NewSignature(recv, params, results, variadic)
}
func (r *importReader) paramList() *types.Tuple {
xs := make([]*types.Var, r.uint64())
for i := range xs {
xs[i] = r.param()
}
return types.NewTuple(xs...)
}
func (r *importReader) param() *types.Var {
pos := r.pos()
name := r.ident()
typ := r.typ()
return types.NewParam(pos, r.currPkg, name, typ)
}
func (r *importReader) bool() bool {
return r.uint64() != 0
}
func (r *importReader) int64() int64 {
n, err := binary.ReadVarint(&r.declReader)
if err != nil {
errorf("readVarint: %v", err)
}
return n
}
func (r *importReader) uint64() uint64 {
n, err := binary.ReadUvarint(&r.declReader)
if err != nil {
errorf("readUvarint: %v", err)
}
return n
}
func (r *importReader) byte() byte {
x, err := r.declReader.ReadByte()
if err != nil {
errorf("declReader.ReadByte: %v", err)
}
return x
}
const deltaNewFile = -64 // see cmd/compile/internal/gc/bexport.go
// Synthesize a token.Pos
type fakeFileSet struct {
fset *token.FileSet
files map[string]*token.File
}
type unsafeFile struct {
_ uintptr
_ string
_ int
_ int
mutex sync.Mutex
lines []int
}
func (f *unsafeFile) SetLines(lines []int) bool {
f.mutex.Lock()
f.lines = lines
f.mutex.Unlock()
return true
}
func (s *fakeFileSet) pos(file string, line, column int) token.Pos {
// TODO(mdempsky): Make use of column.
// Since we don't know the set of needed file positions, we
// reserve maxlines positions per file.
const maxlines = 64 * 1024
f := s.files[file]
if f == nil {
f = s.fset.AddFile(file, -1, maxlines)
s.files[file] = f
// Allocate the fake linebreak indices on first use.
// TODO(adonovan): opt: save ~512KB using a more complex scheme?
fakeLinesOnce.Do(func() {
fakeLines = make([]int, maxlines)
for i := range fakeLines {
fakeLines[i] = i
}
})
(*unsafeFile)(unsafe.Pointer(f)).SetLines(fakeLines)
}
if line > maxlines {
line = 1
}
// Treat the file as if it contained only newlines
// and column=1: use the line number as the offset.
return f.Pos(line - 1)
}
var (
fakeLines []int
fakeLinesOnce sync.Once
)
func chanDir(d int) types.ChanDir {
// tag values must match the constants in cmd/compile/internal/gc/go.go
switch d {
case 1 /* Crecv */ :
return types.RecvOnly
case 2 /* Csend */ :
return types.SendOnly
case 3 /* Cboth */ :
return types.SendRecv
default:
errorf("unexpected channel dir %d", d)
return 0
}
}
var predeclOnce sync.Once
var predecl []types.Type // initialized lazily
func predeclared() []types.Type {
predeclOnce.Do(func() {
// initialize lazily to be sure that all
// elements have been initialized before
predecl = []types.Type{ // basic types
types.Typ[types.Bool],
types.Typ[types.Int],
types.Typ[types.Int8],
types.Typ[types.Int16],
types.Typ[types.Int32],
types.Typ[types.Int64],
types.Typ[types.Uint],
types.Typ[types.Uint8],
types.Typ[types.Uint16],
types.Typ[types.Uint32],
types.Typ[types.Uint64],
types.Typ[types.Uintptr],
types.Typ[types.Float32],
types.Typ[types.Float64],
types.Typ[types.Complex64],
types.Typ[types.Complex128],
types.Typ[types.String],
// basic type aliases
types.Universe.Lookup("byte").Type(),
types.Universe.Lookup("rune").Type(),
// error
types.Universe.Lookup("error").Type(),
// untyped types
types.Typ[types.UntypedBool],
types.Typ[types.UntypedInt],
types.Typ[types.UntypedRune],
types.Typ[types.UntypedFloat],
types.Typ[types.UntypedComplex],
types.Typ[types.UntypedString],
types.Typ[types.UntypedNil],
// package unsafe
types.Typ[types.UnsafePointer],
// invalid type
types.Typ[types.Invalid], // only appears in packages with errors
// used internally by gc; never used by this package or in .a files
anyType{},
}
})
return predecl
}
type anyType struct{}
func (t anyType) Underlying() types.Type { return t }
func (t anyType) String() string { return "any" }
go-tools-2021.1.2/internal/go/gcimporter/newInterface10.go 0000664 0000000 0000000 00000001111 14143223131 0023164 0 ustar 00root root 0000000 0000000 // 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.
// +build !go1.11
package gcimporter
import "go/types"
func newInterface(methods []*types.Func, embeddeds []types.Type) *types.Interface {
named := make([]*types.Named, len(embeddeds))
for i, e := range embeddeds {
var ok bool
named[i], ok = e.(*types.Named)
if !ok {
panic("embedding of non-defined interfaces in interfaces is not supported before Go 1.11")
}
}
return types.NewInterface(methods, named)
}
go-tools-2021.1.2/internal/go/gcimporter/newInterface11.go 0000664 0000000 0000000 00000000542 14143223131 0023174 0 ustar 00root root 0000000 0000000 // 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.
// +build go1.11
package gcimporter
import "go/types"
func newInterface(methods []*types.Func, embeddeds []types.Type) *types.Interface {
return types.NewInterfaceType(methods, embeddeds)
}
go-tools-2021.1.2/internal/go/gcimporter/testdata/ 0000775 0000000 0000000 00000000000 14143223131 0021701 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/go/gcimporter/testdata/a.go 0000664 0000000 0000000 00000000421 14143223131 0022445 0 ustar 00root root 0000000 0000000 // Copyright 2016 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.
// Input for TestIssue13566
package a
import "encoding/json"
type A struct {
a *A
json json.RawMessage
}
go-tools-2021.1.2/internal/go/gcimporter/testdata/b.go 0000664 0000000 0000000 00000000341 14143223131 0022447 0 ustar 00root root 0000000 0000000 // Copyright 2016 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.
// Input for TestIssue13566
package b
import "./a"
type A a.A
go-tools-2021.1.2/internal/go/gcimporter/testdata/exports.go 0000664 0000000 0000000 00000002675 14143223131 0023746 0 ustar 00root root 0000000 0000000 // Copyright 2011 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 used to generate an object file which
// serves as test file for gcimporter_test.go.
package exports
import (
"go/ast"
)
// Issue 3682: Correctly read dotted identifiers from export data.
const init1 = 0
func init() {}
const (
C0 int = 0
C1 = 3.14159265
C2 = 2.718281828i
C3 = -123.456e-789
C4 = +123.456E+789
C5 = 1234i
C6 = "foo\n"
C7 = `bar\n`
)
type (
T1 int
T2 [10]int
T3 []int
T4 *int
T5 chan int
T6a chan<- int
T6b chan (<-chan int)
T6c chan<- (chan int)
T7 <-chan *ast.File
T8 struct{}
T9 struct {
a int
b, c float32
d []string `go:"tag"`
}
T10 struct {
T8
T9
_ *T10
}
T11 map[int]string
T12 interface{}
T13 interface {
m1()
m2(int) float32
}
T14 interface {
T12
T13
m3(x ...struct{}) []T9
}
T15 func()
T16 func(int)
T17 func(x int)
T18 func() float32
T19 func() (x float32)
T20 func(...interface{})
T21 struct{ next *T21 }
T22 struct{ link *T23 }
T23 struct{ link *T22 }
T24 *T24
T25 *T26
T26 *T27
T27 *T25
T28 func(T28) T28
)
var (
V0 int
V1 = -991.0
)
func F1() {}
func F2(x int) {}
func F3() int { return 0 }
func F4() float32 { return 0 }
func F5(a, b, c int, u, v, w struct{ x, y T1 }, more ...interface{}) (p, q, r chan<- T10)
func (p *T1) M1()
go-tools-2021.1.2/internal/go/gcimporter/testdata/issue15920.go 0000664 0000000 0000000 00000000524 14143223131 0023762 0 ustar 00root root 0000000 0000000 // Copyright 2016 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 p
// The underlying type of Error is the underlying type of error.
// Make sure we can import this again without problems.
type Error error
func F() Error { return nil }
go-tools-2021.1.2/internal/go/gcimporter/testdata/issue20046.go 0000664 0000000 0000000 00000000304 14143223131 0023751 0 ustar 00root root 0000000 0000000 // 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 p
var V interface {
M()
}
go-tools-2021.1.2/internal/go/gcimporter/testdata/issue25301.go 0000664 0000000 0000000 00000000430 14143223131 0023750 0 ustar 00root root 0000000 0000000 // 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.
package issue25301
type (
A = interface {
M()
}
T interface {
A
}
S struct{}
)
func (S) M() { println("m") }
go-tools-2021.1.2/internal/go/gcimporter/testdata/p.go 0000664 0000000 0000000 00000000354 14143223131 0022471 0 ustar 00root root 0000000 0000000 // Copyright 2016 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.
// Input for TestIssue15517
package p
const C = 0
var V int
func F() {}
go-tools-2021.1.2/internal/go/gcimporter/testdata/versions/ 0000775 0000000 0000000 00000000000 14143223131 0023551 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/go/gcimporter/testdata/versions/test.go 0000664 0000000 0000000 00000001757 14143223131 0025071 0 ustar 00root root 0000000 0000000 // Copyright 2016 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 copy of $GOROOT/src/go/internal/gcimporter/testdata/versions.test.go.
// To create a test case for a new export format version,
// build this package with the latest compiler and store
// the resulting .a file appropriately named in the versions
// directory. The VersionHandling test will pick it up.
//
// In the testdata/versions:
//
// go build -o test_go1.$X_$Y.a test.go
//
// with $X = Go version and $Y = export format version
// (add 'b' or 'i' to distinguish between binary and
// indexed format starting with 1.11 as long as both
// formats are supported).
//
// Make sure this source is extended such that it exercises
// whatever export format change has taken place.
package test
// Any release before and including Go 1.7 didn't encode
// the package for a blank struct field.
type BlankField struct {
_ int
}
go-tools-2021.1.2/internal/go/gcimporter/testdata/versions/test_go1.11_0i.a 0000664 0000000 0000000 00000004564 14143223131 0026261 0 ustar 00root root 0000000 0000000 !
__.PKGDEF 0 0 0 644 263 `
go object darwin amd64 devel +be36bd996e Tue Jun 12 22:09:45 2018 +0000 X:framepointer
build id "InwPkoa6lIvmygS5jZ-Z/kTt3lDm-5SNRz1GMyyEG"
----
$$B
i P<$GOROOT/src/go/internal/gcimporter/testdata/versions/test.go _test
BlankField=0 > =T. =@ E
$$
_go_.o 0 0 0 644 2028 `
go object darwin amd64 devel +be36bd996e Tue Jun 12 22:09:45 2018 +0000 X:framepointer
build id "InwPkoa6lIvmygS5jZ-Z/kTt3lDm-5SNRz1GMyyEG"
----
!
go19ld ώ0type..hash."".BlankField ώp ώ&type.*"".BlankField ώh ώtype.uintptr ώ~r2 ώTgclocalsΒ·2a5305abe05176240e61b8620e19a815 ώTgclocalsΒ·33cdeccccebe80329f1fdbee7f5874cb ώ.gofile.. ώ,type..eq."".BlankField ώq ώtype.bool ώTgclocalsΒ·f207267fbf96a0178e8758c6e3e0ce28 ώ>go.loc.type..hash."".BlankField ώ@go.info.type..hash."".BlankField ώ,go.info.*"".BlankField ώ go.info.uintptr ώBgo.range.type..hash."".BlankField ώDgo.isstmt.type..hash."".BlankField ώ:go.loc.type..eq."".BlankField ώgo.range.type..eq."".BlankField ώ@go.isstmt.type..eq."".BlankField ώ8type..hashfunc."".BlankField ώ4type..eqfunc."".BlankField ώ.type..alg."".BlankField ώ"runtime.gcbits.01 ώ@type..namedata.*test.BlankField. ώ runtime.algarray ώ$type."".BlankField ώ runtime.gcbits. ώ(type..importpath."". ώ"type..namedata._- ώtype.int Β: HD$HD$Γ ΖD$Γ type..hash."".BlankField p h ~r2 type..eq."".BlankField p q ~r2 *test.BlankField ‘4f 6 ;_/Users/gri/go/src/go/internal/gcimporter/testdata/versions _ KΥ ( ώ 0
ώ 0 ώ
ώ € € 4 DX: l8 8 "8 "ώ $ ώ &
ώ
( ώ* 0 @ T: h8 |8 8 ,ώ . ώ 0
ώ2 ώ4 ώ6 2 4ώ8 ώ:& & ώp p0 <@ 8P
:` >ώ@ ώB| | ώD ώ> π π0 6@ @P
:X
` Bpΐ>
Bΐ DΠ Fώ ώ ώ go19ld go-tools-2021.1.2/internal/go/gcimporter/testdata/versions/test_go1.11_999i.a 0000664 0000000 0000000 00000004564 14143223131 0026454 0 ustar 00root root 0000000 0000000 !
__.PKGDEF 0 0 0 644 264 `
go object darwin amd64 devel +538833eca6 Tue Jun 12 17:33:59 2018 -0700 X:framepointer
build id "KNwWkpbSPSgR7u1li_02/yvyfRpsIstTPxD0oXy47"
----
$$B
iηP<$GOROOT/src/go/internal/gcimporter/testdata/versions/test.go _test
BlankField=4 > =T2 =@ E
$$
_go_.o 0 0 0 644 2028 `
go object darwin amd64 devel +538833eca6 Tue Jun 12 17:33:59 2018 -0700 X:framepointer
build id "KNwWkpbSPSgR7u1li_02/yvyfRpsIstTPxD0oXy47"
----
!
go19ld ώ0type..hash."".BlankField ώp ώ&type.*"".BlankField ώh ώtype.uintptr ώ~r2 ώTgclocalsΒ·2a5305abe05176240e61b8620e19a815 ώTgclocalsΒ·33cdeccccebe80329f1fdbee7f5874cb ώ.gofile.. ώ,type..eq."".BlankField ώq ώtype.bool ώTgclocalsΒ·f207267fbf96a0178e8758c6e3e0ce28 ώ>go.loc.type..hash."".BlankField ώ@go.info.type..hash."".BlankField ώ,go.info.*"".BlankField ώ go.info.uintptr ώBgo.range.type..hash."".BlankField ώDgo.isstmt.type..hash."".BlankField ώ:go.loc.type..eq."".BlankField ώgo.range.type..eq."".BlankField ώ@go.isstmt.type..eq."".BlankField ώ8type..hashfunc."".BlankField ώ4type..eqfunc."".BlankField ώ.type..alg."".BlankField ώ"runtime.gcbits.01 ώ@type..namedata.*test.BlankField. ώ runtime.algarray ώ$type."".BlankField ώ runtime.gcbits. ώ(type..importpath."". ώ"type..namedata._- ώtype.int Β: HD$HD$Γ ΖD$Γ type..hash."".BlankField p h ~r2 type..eq."".BlankField p q ~r2 *test.BlankField ‘4f 6 ;_/Users/gri/go/src/go/internal/gcimporter/testdata/versions _ KΥ ( ώ 0
ώ 0 ώ
ώ € € 4 DX: l8 8 "8 "ώ $ ώ &
ώ
( ώ* 0 @ T: h8 |8 8 ,ώ . ώ 0
ώ2 ώ4 ώ6 2 4ώ8 ώ:& & ώp p0 <@ 8P
:` >ώ@ ώB| | ώD ώ> π π0 6@ @P
:X
` Bpΐ>
Bΐ DΠ Fώ ώ ώ go19ld go-tools-2021.1.2/internal/gosmith/ 0000775 0000000 0000000 00000000000 14143223131 0016762 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/gosmith/LICENSE 0000664 0000000 0000000 00000002637 14143223131 0017777 0 ustar 00root root 0000000 0000000 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.
go-tools-2021.1.2/internal/gosmith/README.md 0000664 0000000 0000000 00000003517 14143223131 0020247 0 ustar 00root root 0000000 0000000 ```GoSmith``` generates random, but legal, [Go programs](http://golang.org) to test Go compilers.
Bugs found to date:
* [31 bugs](https://code.google.com/p/go/issues/list?can=1&q=label%3AGoSmith+-label%3ADocumentation+-status%3AInvalid&sort=-id&colspec=ID+Status+Stars+Release+Owner+Repo+Summary&cells=tiles) in gc compiler
* [18 bugs](https://gcc.gnu.org/bugzilla/buglist.cgi?bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=SUSPENDED&bug_status=WAITING&bug_status=REOPENED&bug_status=RESOLVED&bug_status=VERIFIED&bug_status=CLOSED&cf_known_to_fail_type=allwords&cf_known_to_work_type=allwords&f0=OP&f1=OP&f2=product&f3=component&f4=alias&f5=short_desc&f6=status_whiteboard&f7=content&f8=CP&f9=CP&j1=OR&list_id=97425&o2=substring&o3=substring&o4=substring&o5=substring&o6=substring&o7=matches&query_format=advanced&v2=GoSmith&v3=GoSmith&v4=GoSmith&v5=GoSmith&v6=GoSmith&v7=%22GoSmith%22) in gccgo compiler
* [5 bugs](https://github.com/go-llvm/llgo/issues?labels=GoSmith) in llgo compiler (+[bug 1](https://github.com/go-llvm/llgo/issues/174), +[bug 2](https://github.com/go-llvm/llgo/issues/175), +[bug 3](https://github.com/go-llvm/llgo/issues/176), +[bug 4](https://github.com/go-llvm/llgo/issues/177))
* [3 bugs](https://code.google.com/p/go/issues/list?can=1&q=label%3AGoSmith+label%3ADocumentation+-status%3AInvalid&sort=-id&colspec=ID+Status+Stars+Release+Owner+Repo+Summary&cells=tiles) in the spec were uncovered due to this work
Usage instructions:
```
# Bootstrap Go implementation:
./make.bash
GOARCH=386 go tool dist bootstrap
GOARCH=arm go tool dist bootstrap
GOARCH=386 go install std
GOARCH=arm go install std
go install -race -a std
go install -a std
# Download binaries:
go get -u code.google.com/p/gosmith/gosmith
go get -u code.google.com/p/go.tools/cmd/ssadump
# Test:
go run driver.go -checkers=amd64,386,arm,exec
```
go-tools-2021.1.2/internal/gosmith/UPSTREAM 0000664 0000000 0000000 00000000416 14143223131 0020146 0 ustar 00root root 0000000 0000000 This package is a copy of github.com/dvyukov/gosmith.
It is almost a verbatim copy of upstream,
with the only modification being that global state has been converted into a struct.
The last upstream commit we've looked at was: b51fcdcb8a253aacf4dddccf27d51a8f5c0a1952
go-tools-2021.1.2/internal/gosmith/context.go 0000664 0000000 0000000 00000032515 14143223131 0021003 0 ustar 00root root 0000000 0000000 package main
/*
Large uncovered parts are:
- methods
- type assignability and identity
- consts
- interfaces, types implementing interfaces, type assertions
- ... parameters
*/
import (
"bufio"
"fmt"
"math/rand"
"os"
"path/filepath"
"strings"
)
type Smith struct {
curPackage int
curBlock *Block
curBlockPos int
curFunc *Func
packages [NPackages]*Package
idSeq int
typeDepth int
stmtCount int
exprDepth int
exprCount int
totalExprCount int
predefinedTypes []*Type
stringType *Type
boolType *Type
intType *Type
byteType *Type
efaceType *Type
runeType *Type
float32Type *Type
float64Type *Type
complex64Type *Type
complex128Type *Type
statements []func()
expressions []func(res *Type) string
rng *rand.Rand
}
const (
NPackages = 3
NFiles = 3
NStatements = 10
NExprDepth = 4
NExprCount = 10
NTotalExprCount = 50
/*
NStatements = 30
NExprDepth = 6
NExprCount = 20
NTotalExprCount = 1000
*/
)
type Package struct {
name string
imports map[string]bool
top *Block
undefFuncs []*Func
undefVars []*Var
toplevVars []*Var
toplevFuncs []*Func
}
type Block struct {
str string
parent *Block
subBlock *Block
extendable bool
isBreakable bool
isContinuable bool
funcBoundary bool
sub []*Block
consts []*Const
types []*Type
funcs []*Func
vars []*Var
}
type Func struct {
name string
args []*Type
rets []*Type
}
type Var struct {
id string
typ *Type
block *Block
used bool
}
type Const struct {
}
func (smith *Smith) writeProgram(dir string) {
smith.initTypes()
smith.initExpressions()
smith.initStatements()
smith.initProgram()
for pi := range smith.packages {
smith.genPackage(pi)
}
smith.serializeProgram(dir)
}
func (smith *Smith) initProgram() {
smith.packages[0] = smith.newPackage("main")
smith.packages[0].undefFuncs = []*Func{
{name: "init", args: []*Type{}, rets: []*Type{}},
{name: "init", args: []*Type{}, rets: []*Type{}},
{name: "main", args: []*Type{}, rets: []*Type{}},
}
if !*singlepkg {
smith.packages[1] = smith.newPackage("a")
smith.packages[2] = smith.newPackage("b")
}
}
func (smith *Smith) newPackage(name string) *Package {
return &Package{name: name, imports: make(map[string]bool), top: &Block{extendable: true}}
}
func (smith *Smith) genPackage(pi int) {
smith.typeDepth = 0
smith.stmtCount = 0
smith.exprDepth = 0
smith.exprCount = 0
smith.totalExprCount = 0
p := smith.packages[pi]
if p == nil {
return
}
for len(p.undefFuncs) != 0 || len(p.undefVars) != 0 {
if len(p.undefFuncs) != 0 {
f := p.undefFuncs[len(p.undefFuncs)-1]
p.undefFuncs = p.undefFuncs[:len(p.undefFuncs)-1]
smith.genToplevFunction(pi, f)
}
if len(p.undefVars) != 0 {
v := p.undefVars[len(p.undefVars)-1]
p.undefVars = p.undefVars[:len(p.undefVars)-1]
smith.genToplevVar(pi, v)
}
}
}
func F(f string, args ...interface{}) string {
return fmt.Sprintf(f, args...)
}
func (smith *Smith) line(f string, args ...interface{}) {
s := F(f, args...)
b := &Block{parent: smith.curBlock, str: s}
if smith.curBlockPos+1 == len(smith.curBlock.sub) {
smith.curBlock.sub = append(smith.curBlock.sub, b)
} else {
smith.curBlock.sub = append(smith.curBlock.sub, nil)
copy(smith.curBlock.sub[smith.curBlockPos+2:], smith.curBlock.sub[smith.curBlockPos+1:])
smith.curBlock.sub[smith.curBlockPos+1] = b
}
smith.curBlockPos++
}
func (smith *Smith) resetContext(pi int) {
smith.curPackage = pi
p := smith.packages[pi]
smith.curBlock = p.top
smith.curBlockPos = len(smith.curBlock.sub) - 1
smith.curFunc = nil
}
func (smith *Smith) genToplevFunction(pi int, f *Func) {
smith.resetContext(pi)
smith.curFunc = f
smith.enterBlock(true)
smith.enterBlock(true)
argIds := make([]string, len(f.args))
argStr := ""
for i, a := range f.args {
argIds[i] = smith.newId("Param")
if i != 0 {
argStr += ", "
}
argStr += argIds[i] + " " + a.id
}
smith.line("func %v(%v)%v {", f.name, argStr, fmtTypeList(f.rets, false))
for i, a := range f.args {
smith.defineVar(argIds[i], a)
}
smith.curBlock.funcBoundary = true
smith.genBlock()
smith.leaveBlock()
smith.stmtReturn()
smith.line("}")
smith.leaveBlock()
if f.name != "init" {
smith.packages[smith.curPackage].toplevFuncs = append(smith.packages[smith.curPackage].toplevFuncs, f)
}
}
func (smith *Smith) genToplevVar(pi int, v *Var) {
smith.resetContext(pi)
smith.enterBlock(true)
smith.line("var %v = %v", v.id, smith.rvalue(v.typ))
smith.leaveBlock()
smith.packages[smith.curPackage].toplevVars = append(smith.packages[smith.curPackage].toplevVars, v)
}
func (smith *Smith) genBlock() {
smith.enterBlock(false)
for smith.rnd(10) != 0 {
smith.genStatement()
}
smith.leaveBlock()
}
func (smith *Smith) serializeProgram(dir string) {
for _, p := range smith.packages {
if p == nil {
continue
}
path := filepath.Join(dir, "src", p.name)
os.MkdirAll(path, os.ModePerm)
nf := NFiles
if *singlefile {
nf = 1
}
files := make([]*bufio.Writer, nf)
for i := range files {
fname := filepath.Join(path, fmt.Sprintf("%v.go", i))
f, err := os.Create(fname)
if err != nil {
fmt.Fprintf(os.Stdout, "failed to create a file: %v\n", err)
os.Exit(1)
}
w := bufio.NewWriter(bufio.NewWriter(f))
files[i] = w
defer func() {
w.Flush()
f.Close()
}()
fmt.Fprintf(w, "package %s\n", p.name)
for imp := range p.imports {
fmt.Fprintf(w, "import \"%s\"\n", imp)
}
if i == 0 && p.name == "main" {
fmt.Fprintf(w, "import \"runtime\"\n")
fmt.Fprintf(w, "func init() {\n")
fmt.Fprintf(w, " go func() {\n")
fmt.Fprintf(w, " for {\n")
fmt.Fprintf(w, " runtime.GC()\n")
fmt.Fprintf(w, " runtime.Gosched()\n")
fmt.Fprintf(w, " }\n")
fmt.Fprintf(w, " }()\n")
fmt.Fprintf(w, "}\n")
}
for imp := range p.imports {
fmt.Fprintf(w, "var _ = %s.UsePackage\n", imp)
}
if i == 0 {
fmt.Fprintf(w, "var UsePackage = 0\n")
fmt.Fprintf(w, "var SINK interface{}\n")
}
}
for _, decl := range p.top.sub {
serializeBlock(files[smith.rnd(len(files))], decl, 0)
}
}
path := filepath.Join(dir, "src", "a")
os.MkdirAll(path, os.ModePerm)
fname := filepath.Join(path, "0_test.go")
f, err := os.Create(fname)
if err != nil {
fmt.Fprintf(os.Stdout, "failed to create a file: %v\n", err)
os.Exit(1)
}
f.Write([]byte("package a\n"))
f.Close()
}
func serializeBlock(w *bufio.Writer, b *Block, d int) {
if true {
if b.str != "" {
w.WriteString(b.str)
w.WriteString("\n")
}
} else {
w.WriteString("/*" + strings.Repeat("*", d) + "*/ ")
w.WriteString(b.str)
w.WriteString(F(" // ext=%v vars=%v types=%v", b.extendable, len(b.vars), len(b.types)))
w.WriteString("\n")
}
for _, b1 := range b.sub {
serializeBlock(w, b1, d+1)
}
}
func (smith *Smith) vars() []*Var {
var vars []*Var
vars = append(vars, smith.packages[smith.curPackage].toplevVars...)
var f func(b *Block, pos int)
f = func(b *Block, pos int) {
for _, b1 := range b.sub[:pos+1] {
vars = append(vars, b1.vars...)
}
if b.parent != nil {
pos := len(b.parent.sub) - 1
if b.subBlock != nil {
pos = -2
for i, b1 := range b.parent.sub {
if b1 == b.subBlock {
pos = i
break
}
}
if pos == -2 {
panic("bad")
}
}
f(b.parent, pos)
}
}
f(smith.curBlock, smith.curBlockPos)
return vars
}
func (smith *Smith) types() []*Type {
var types []*Type
types = append(types, smith.predefinedTypes...)
var f func(b *Block, pos int)
f = func(b *Block, pos int) {
for _, b1 := range b.sub[:pos+1] {
types = append(types, b1.types...)
}
if b.parent != nil {
pos := len(b.parent.sub) - 1
if b.subBlock != nil {
pos = -2
for i, b1 := range b.parent.sub {
if b1 == b.subBlock {
pos = i
break
}
}
if pos == -2 {
panic("bad")
}
}
f(b.parent, pos)
}
}
f(smith.curBlock, smith.curBlockPos)
return types
}
func (smith *Smith) defineVar(id string, t *Type) {
v := &Var{id: id, typ: t, block: smith.curBlock}
b := smith.curBlock.sub[smith.curBlockPos]
b.vars = append(b.vars, v)
}
func (smith *Smith) defineType(t *Type) {
b := smith.curBlock.sub[smith.curBlockPos]
b.types = append(b.types, t)
}
func (smith *Smith) materializeVar(t *Type) string {
// TODO: generate var in another package
id := smith.newId("Var")
curBlock0 := smith.curBlock
curBlockPos0 := smith.curBlockPos
curBlockLen0 := len(smith.curBlock.sub)
exprDepth0 := smith.exprDepth
exprCount0 := smith.exprCount
smith.exprDepth = 0
smith.exprCount = 0
defer func() {
if smith.curBlock == curBlock0 {
curBlockPos0 += len(smith.curBlock.sub) - curBlockLen0
}
smith.curBlock = curBlock0
smith.curBlockPos = curBlockPos0
smith.exprDepth = exprDepth0
smith.exprCount = exprCount0
}()
loop:
for {
if smith.curBlock.parent == nil {
break
}
if !smith.curBlock.extendable || smith.curBlockPos < 0 {
if smith.curBlock.subBlock == nil {
smith.curBlockPos = len(smith.curBlock.parent.sub) - 2
} else {
smith.curBlockPos = -2
for i, b1 := range smith.curBlock.parent.sub {
if b1 == smith.curBlock.subBlock {
smith.curBlockPos = i
break
}
}
if smith.curBlockPos == -2 {
panic("bad")
}
}
smith.curBlock = smith.curBlock.parent
continue
}
if smith.rnd(3) == 0 {
break
}
if smith.curBlockPos >= 0 {
b := smith.curBlock.sub[smith.curBlockPos]
for _, t1 := range b.types {
if dependsOn(t, t1) {
break loop
}
}
}
smith.curBlockPos--
}
if smith.curBlock.parent == nil {
for i := smith.curPackage; i < NPackages; i++ {
if smith.rndBool() || i == NPackages-1 || *singlepkg {
if i == smith.curPackage {
// emit global var into the current package
smith.enterBlock(true)
smith.line("var %v = %v", id, smith.rvalue(t))
smith.packages[smith.curPackage].toplevVars = append(smith.packages[smith.curPackage].toplevVars, &Var{id: id, typ: t})
smith.leaveBlock()
} else {
// emit global var into another package
smith.packages[i].undefVars = append(smith.packages[i].undefVars, &Var{id: id, typ: t})
smith.packages[smith.curPackage].imports[smith.packages[i].name] = true
id = smith.packages[i].name + "." + id
}
break
}
}
} else {
// emit local var
smith.line("%v := %v", id, smith.rvalue(t))
smith.defineVar(id, t)
}
return id
}
func (smith *Smith) materializeFunc(rets []*Type) *Func {
f := &Func{name: smith.newId("Func"), args: smith.atypeList(TraitGlobal), rets: rets}
curBlock0 := smith.curBlock
curBlockPos0 := smith.curBlockPos
curFunc0 := smith.curFunc
exprDepth0 := smith.exprDepth
exprCount0 := smith.exprCount
smith.exprDepth = 0
smith.exprCount = 0
defer func() {
smith.curBlock = curBlock0
smith.curBlockPos = curBlockPos0
smith.curFunc = curFunc0
smith.exprDepth = exprDepth0
smith.exprCount = exprCount0
}()
if smith.rndBool() && !*singlepkg && smith.curPackage != NPackages-1 {
for _, r1 := range rets {
if dependsOn(r1, nil) {
goto thisPackage
}
}
for _, t := range f.args {
if dependsOn(t, nil) {
goto thisPackage
}
}
// emit global var into another package
newF := new(Func)
*newF = *f
smith.packages[smith.curPackage+1].undefFuncs = append(smith.packages[smith.curPackage+1].undefFuncs, newF)
smith.packages[smith.curPackage].imports[smith.packages[smith.curPackage+1].name] = true
f.name = smith.packages[smith.curPackage+1].name + "." + f.name
return f
}
thisPackage:
smith.genToplevFunction(smith.curPackage, f)
return f
}
func (smith *Smith) materializeGotoLabel() string {
// TODO: move label up
id := smith.newId("Label")
curBlock0 := smith.curBlock
curBlockPos0 := smith.curBlockPos
curBlockLen0 := len(smith.curBlock.sub)
defer func() {
if smith.curBlock == curBlock0 {
curBlockPos0 += len(smith.curBlock.sub) - curBlockLen0
}
smith.curBlock = curBlock0
smith.curBlockPos = curBlockPos0
}()
for {
if smith.curBlock.parent.funcBoundary && smith.curBlockPos <= 0 {
break
}
if !smith.curBlock.extendable || smith.curBlockPos < 0 {
if smith.curBlock.subBlock != nil {
// we should have been stopped at func boundary
panic("bad")
}
smith.curBlock = smith.curBlock.parent
smith.curBlockPos = len(smith.curBlock.sub) - 2
continue
}
if smith.rnd(3) == 0 {
break
}
smith.curBlockPos--
}
smith.line("%v:", id)
return id
}
func (smith *Smith) rnd(n int) int {
return smith.rng.Intn(n)
}
func (smith *Smith) rndBool() bool {
return smith.rnd(2) == 0
}
func (smith *Smith) choice(ch ...string) string {
return ch[smith.rnd(len(ch))]
}
func (smith *Smith) newId(prefix string) string {
if prefix[0] < 'A' || prefix[0] > 'Z' {
panic("unexported id")
}
smith.idSeq++
return fmt.Sprintf("%v%v", prefix, smith.idSeq)
}
func (smith *Smith) enterBlock(nonextendable bool) {
b := &Block{parent: smith.curBlock, extendable: !nonextendable}
b.isBreakable = smith.curBlock.isBreakable
b.isContinuable = smith.curBlock.isContinuable
smith.curBlock.sub = append(smith.curBlock.sub, b)
smith.curBlock = b
smith.curBlockPos = -1
}
func (smith *Smith) leaveBlock() {
for _, b := range smith.curBlock.sub {
for _, v := range b.vars {
if !v.used {
smith.line("_ = %v", v.id)
}
}
}
smith.curBlock = smith.curBlock.parent
smith.curBlockPos = len(smith.curBlock.sub) - 1
}
go-tools-2021.1.2/internal/gosmith/expr.go 0000664 0000000 0000000 00000027702 14143223131 0020277 0 ustar 00root root 0000000 0000000 package main
import (
"bytes"
"fmt"
)
func (smith *Smith) initExpressions() {
smith.expressions = []func(res *Type) string{
smith.exprLiteral,
smith.exprVar,
smith.exprFunc,
smith.exprSelectorField,
smith.exprRecv,
smith.exprArith,
smith.exprEqual,
smith.exprOrder,
smith.exprCall,
smith.exprCallBuiltin,
smith.exprAddress,
smith.exprDeref,
smith.exprSlice,
smith.exprIndexSlice,
smith.exprIndexArray,
smith.exprIndexString,
smith.exprIndexMap,
smith.exprConversion,
}
}
func (smith *Smith) expression(res *Type) string {
smith.exprCount++
smith.totalExprCount++
if smith.exprDepth >= NExprDepth || smith.exprCount >= NExprCount || smith.totalExprCount >= NTotalExprCount {
return res.literal()
}
for {
smith.exprDepth++
s := smith.expressions[smith.rnd(len(smith.expressions))](res)
smith.exprDepth--
if s != "" {
return s
}
}
}
func (smith *Smith) rvalue(t *Type) string {
return smith.expression(t)
}
// rvalue, but not a const
// used to index arrays and strings
func (smith *Smith) nonconstRvalue(t *Type) string {
if t.class != ClassNumeric {
panic("bad")
}
trying:
for {
res := ""
switch smith.choice("lvalue", "call", "len", "selector", "recv", "arith", "indexMap", "conv") {
case "lvalue":
res = smith.lvalue(t)
case "call":
res = smith.exprCall(t)
case "len":
tt := smith.atype(TraitLenCapable)
fn := smith.choice("len", "cap")
if (tt.class == ClassString || tt.class == ClassMap) && fn == "cap" {
break
}
if tt.class == ClassArray {
// len/cap are const
break
}
res = F("(%v)((%v)(%v))", t.id, fn, smith.lvalue(tt))
case "selector":
res = smith.exprSelectorField(t)
case "recv":
res = smith.exprRecv(t)
case "arith":
res = F("(%v) %v (%v)", smith.lvalue(t), smith.choice("+", "-"), smith.rvalue(t))
case "indexMap":
res = smith.exprIndexMap(t)
case "conv":
res = F("(%v)(%v %v)", t.id, smith.lvalue(smith.atype(ClassNumeric)), smith.choice("", ","))
default:
panic("bad")
}
if res == "" {
continue trying
}
return res
}
}
func (smith *Smith) lvalue(t *Type) string {
for {
switch smith.choice("var", "indexSlice", "indexArray", "selector", "deref") {
case "var":
return smith.exprVar(t)
case "indexSlice":
return smith.exprIndexSlice(t)
case "indexArray":
return F("(%v)[%v]", smith.lvalue(smith.arrayOf(t)), smith.nonconstRvalue(smith.intType))
case "selector":
for i := 0; i < 10; i++ {
st := smith.atype(ClassStruct)
for _, e := range st.elems {
if e.typ == t {
return F("(%v).%v", smith.lvalue(st), e.id)
}
}
}
continue
case "deref":
return smith.exprDeref(t)
default:
panic("bad")
}
}
}
func (smith *Smith) lvalueOrBlank(t *Type) string {
for {
switch smith.choice("lvalue", "map", "blank") {
case "lvalue":
return smith.lvalue(t)
case "map":
if e := smith.exprIndexMap(t); e != "" {
return e
}
case "blank":
return "_"
default:
panic("bad")
}
}
}
func (smith *Smith) lvalueOrMapIndex(t *Type) string {
for {
switch smith.choice("lvalue", "map") {
case "lvalue":
return smith.lvalue(t)
case "map":
if e := smith.exprIndexMap(t); e != "" {
return e
}
default:
panic("bad")
}
}
}
func (smith *Smith) fmtRvalueList(list []*Type) string {
var buf bytes.Buffer
for i, t := range list {
if i != 0 {
buf.Write([]byte{','})
}
fmt.Fprintf(&buf, "%v", smith.rvalue(t))
}
return buf.String()
}
func (smith *Smith) fmtLvalueList(list []*Type) string {
var buf bytes.Buffer
for i, t := range list {
if i != 0 {
buf.Write([]byte{','})
}
buf.WriteString(smith.lvalueOrBlank(t))
}
return buf.String()
}
func (smith *Smith) fmtOasVarList(list []*Type) (str string, newVars []*Var) {
allVars := smith.vars()
var buf bytes.Buffer
for i, t := range list {
expr := "_"
// First, try to find an existing var in the same scope.
if smith.rndBool() {
for i, v := range allVars {
if v.typ == t && v.block == smith.curBlock {
allVars[i] = allVars[len(allVars)-1]
allVars = allVars[:len(allVars)-1]
expr = v.id
break
}
}
}
if smith.rndBool() || (i == len(list)-1 && len(newVars) == 0) {
expr = smith.newId("Var")
newVars = append(newVars, &Var{id: expr, typ: t})
}
if i != 0 {
buf.WriteString(", ")
}
buf.WriteString(expr)
}
return buf.String(), newVars
}
func (smith *Smith) exprLiteral(res *Type) string {
if res.complexLiteral != nil {
return res.complexLiteral()
}
return res.literal()
}
func (smith *Smith) exprVar(res *Type) string {
for _, v := range smith.vars() {
if v.typ == res {
return v.id
}
}
return smith.materializeVar(res)
}
func (smith *Smith) exprSelectorField(res *Type) string {
for i := 0; i < 10; i++ {
st := smith.atype(ClassStruct)
for _, e := range st.elems {
if e.typ == res {
return F("(%v).%v", smith.rvalue(st), e.id)
}
}
}
return ""
}
func (smith *Smith) exprFunc(res *Type) string {
if !smith.satisfiesTrait(res, TraitGlobal) {
return ""
}
var f *Func
for _, f1 := range smith.packages[smith.curPackage].toplevFuncs {
if len(f1.rets) == 1 && f1.rets[0] == res {
f = f1
break
}
}
if f == nil {
f = smith.materializeFunc([]*Type{res})
}
if smith.rndBool() {
return F("%v(%v)", f.name, smith.fmtRvalueList(f.args))
} else {
var f0 *Func
loop:
for _, f1 := range smith.packages[smith.curPackage].toplevFuncs {
if len(f1.rets) == len(f.args) {
for i := range f.args {
// TODO: check assignability
if f1.rets[i] != f.args[i] {
continue loop
}
}
f0 = f1
break
}
}
if f0 == nil {
f0 = smith.materializeFunc(f.args)
}
return F("%v(%v(%v))", f.name, f0.name, smith.fmtRvalueList(f0.args))
}
}
func (smith *Smith) exprAddress(res *Type) string {
if res.class != ClassPointer {
return ""
}
if res.ktyp.class == ClassStruct && smith.rndBool() {
return F("&%v", res.ktyp.complexLiteral())
}
return F("(%v)(&(%v))", res.id, smith.lvalue(res.ktyp))
}
func (smith *Smith) exprDeref(res *Type) string {
return F("(*(%v))", smith.lvalue(pointerTo(res)))
}
func (smith *Smith) exprRecv(res *Type) string {
t := smith.chanOf(res)
return F("(<- %v)", smith.rvalue(t))
}
func (smith *Smith) exprArith(res *Type) string {
if res.class != ClassNumeric && res.class != ClassComplex {
return ""
}
// "/" causes division by zero
// "*" causes generation of -1 index in int(real(1i * 1i))
return F("(%v) + (%v)", smith.rvalue(res), smith.rvalue(res))
}
func (smith *Smith) exprEqual(res *Type) string {
if res != smith.boolType {
return ""
}
t := smith.atype(TraitComparable)
return F("(%v) %v (%v)", smith.rvalue(t), smith.choice("==", "!="), smith.rvalue(t))
}
func (smith *Smith) exprOrder(res *Type) string {
if res != smith.boolType {
return ""
}
t := smith.atype(TraitOrdered)
return F("(%v) %v (%v)", smith.rvalue(t), smith.choice("<", "<=", ">", ">="), smith.rvalue(t))
}
func (smith *Smith) exprCall(ret *Type) string {
t := smith.funcOf(smith.atypeList(TraitAny), []*Type{ret})
return F("%v(%v)", smith.rvalue(t), smith.fmtRvalueList(t.styp))
}
func (smith *Smith) exprCallBuiltin(ret *Type) string {
switch fn := smith.choice("append", "cap", "complex", "copy", "imag", "len", "make", "new", "real", "recover"); fn {
case "append":
if ret.class != ClassSlice {
return ""
}
switch smith.choice("one", "two", "slice") {
case "one":
return F("%v(%v, %v)", fn, smith.rvalue(ret), smith.rvalue(ret.ktyp))
case "two":
return F("%v(%v, %v, %v)", fn, smith.rvalue(ret), smith.rvalue(ret.ktyp), smith.rvalue(ret.ktyp))
case "slice":
return F("%v(%v, %v...)", fn, smith.rvalue(ret), smith.rvalue(ret))
default:
panic("bad")
}
case "len", "cap":
if ret != smith.intType { // TODO: must be convertable
return ""
}
t := smith.atype(TraitLenCapable)
if (t.class == ClassString || t.class == ClassMap) && fn == "cap" {
return ""
}
return F("%v(%v)", fn, smith.rvalue(t))
case "copy":
if ret != smith.intType {
return ""
}
return F("%v", smith.exprCopySlice())
case "make":
if ret.class != ClassSlice && ret.class != ClassMap && ret.class != ClassChan {
return ""
}
cap := ""
if ret.class == ClassSlice {
if smith.rndBool() {
cap = F(", %v", smith.rvalue(smith.intType))
} else {
// Careful to not generate "len larger than cap".
cap = F(", 0, %v", smith.rvalue(smith.intType))
}
} else if smith.rndBool() {
cap = F(", %v", smith.rvalue(smith.intType))
}
return F("make(%v %v)", ret.id, cap)
case "new":
if ret.class != ClassPointer {
return ""
}
return F("new(%v)", ret.ktyp.id)
case "recover":
if ret != smith.efaceType {
return ""
}
return "recover()"
case "real", "imag":
if ret == smith.float32Type {
return F("real(%v)", smith.rvalue(smith.complex64Type))
}
if ret == smith.float64Type {
return F("real(%v)", smith.rvalue(smith.complex128Type))
}
return ""
case "complex":
if ret == smith.complex64Type {
return F("complex(%v, %v)", smith.rvalue(smith.float32Type), smith.rvalue(smith.float32Type))
}
if ret == smith.complex128Type {
return F("complex(%v, %v)", smith.rvalue(smith.float64Type), smith.rvalue(smith.float64Type))
}
return ""
default:
panic("bad")
}
}
func (smith *Smith) exprCopySlice() string {
if smith.rndBool() {
t := smith.atype(ClassSlice)
return F("copy(%v, %v)", smith.rvalue(t), smith.rvalue(t))
} else {
return F("copy(%v, %v)", smith.rvalue(smith.sliceOf(smith.byteType)), smith.rvalue(smith.stringType))
}
}
func (smith *Smith) exprSlice(ret *Type) string {
if ret.class != ClassSlice {
return ""
}
i0 := ""
if smith.rndBool() {
i0 = smith.nonconstRvalue(smith.intType)
}
i2 := ""
if smith.rndBool() {
i2 = ":" + smith.nonconstRvalue(smith.intType)
}
i1 := ":"
if smith.rndBool() || i2 != "" {
i1 = ":" + smith.nonconstRvalue(smith.intType)
}
return F("(%v)[%v%v%v]", smith.rvalue(ret), i0, i1, i2)
}
func (smith *Smith) exprIndexSlice(ret *Type) string {
return F("(%v)[%v]", smith.rvalue(smith.sliceOf(ret)), smith.nonconstRvalue(smith.intType))
}
func (smith *Smith) exprIndexString(ret *Type) string {
if ret != smith.byteType {
return ""
}
return F("(%v)[%v]", smith.rvalue(smith.stringType), smith.nonconstRvalue(smith.intType))
}
func (smith *Smith) exprIndexArray(ret *Type) string {
// TODO: also handle indexing of pointers to arrays
return F("(%v)[%v]", smith.rvalue(smith.arrayOf(ret)), smith.nonconstRvalue(smith.intType))
}
func (smith *Smith) exprIndexMap(ret *Type) string {
// TODO: figure out something better
for i := 0; i < 10; i++ {
t := smith.atype(ClassMap)
if t.vtyp == ret {
return F("(%v)[%v]", smith.rvalue(t), smith.rvalue(t.ktyp))
}
}
return ""
}
func (smith *Smith) exprConversion(ret *Type) string {
if ret.class == ClassNumeric {
return F("(%v)(%v %v)", ret.id, smith.rvalue(smith.atype(ClassNumeric)), smith.choice("", ","))
}
if ret.class == ClassComplex {
return F("(%v)(%v %v)", ret.id, smith.rvalue(smith.atype(ClassComplex)), smith.choice("", ","))
}
if ret == smith.stringType {
switch smith.choice("int", "byteSlice", "runeSlice") {
case "int":
// We produce a string of length at least 3, to not produce
// "invalid string index 1 (out of bounds for 1-byte string)"
return F("(%v)((%v) + (1<<24) %v)", ret.id, smith.rvalue(smith.intType), smith.choice("", ","))
case "byteSlice":
return F("(%v)(%v %v)", ret.id, smith.rvalue(smith.sliceOf(smith.byteType)), smith.choice("", ","))
case "runeSlice":
return F("(%v)(%v %v)", ret.id, smith.rvalue(smith.sliceOf(smith.runeType)), smith.choice("", ","))
default:
panic("bad")
}
}
if ret.class == ClassSlice && (ret.ktyp == smith.byteType || ret.ktyp == smith.runeType) {
return F("(%v)(%v %v)", ret.id, smith.rvalue(smith.stringType), smith.choice("", ","))
}
// TODO: handle "x is assignable to T"
// TODO: handle "x's type and T have identical underlying types"
// TODO: handle "x's type and T are unnamed pointer types and their pointer base types have identical underlying types"
return ""
}
go-tools-2021.1.2/internal/gosmith/gosmith.go 0000664 0000000 0000000 00000001114 14143223131 0020760 0 ustar 00root root 0000000 0000000 package main
import (
"flag"
"fmt"
"math/rand"
"os"
)
var (
seed = flag.Int64("seed", 0, "random generator seed")
workdir = flag.String("dir", "", "directory to write the program to")
singlepkg = flag.Bool("singlepkg", false, "generate single-package program")
singlefile = flag.Bool("singlefile", false, "generate single-file packages")
)
func main() {
flag.Parse()
if *workdir == "" {
fmt.Fprintf(os.Stderr, "-dir flag is missing\n")
os.Exit(1)
}
rand.Seed(*seed)
smith := &Smith{
rng: rand.New(rand.NewSource(*seed)),
}
smith.writeProgram(*workdir)
}
go-tools-2021.1.2/internal/gosmith/staticcheck.conf 0000664 0000000 0000000 00000000037 14143223131 0022116 0 ustar 00root root 0000000 0000000 checks = ["inherit", "-U1000"]
go-tools-2021.1.2/internal/gosmith/stmt.go 0000664 0000000 0000000 00000027102 14143223131 0020302 0 ustar 00root root 0000000 0000000 package main
import (
_ "fmt"
)
func (smith *Smith) initStatements() {
smith.statements = []func(){
smith.stmtOas,
smith.stmtAs,
smith.stmtInc,
smith.stmtIf,
smith.stmtFor,
smith.stmtSend,
smith.stmtRecv,
smith.stmtSelect,
smith.stmtSwitchExpr,
smith.stmtSwitchType,
smith.stmtTypeDecl,
smith.stmtVarDecl,
smith.stmtCall,
smith.stmtReturn,
smith.stmtBreak,
smith.stmtContinue,
smith.stmtGoto,
smith.stmtSink,
}
}
func (smith *Smith) genStatement() {
if smith.stmtCount >= NStatements {
return
}
smith.exprCount = 0
smith.stmtCount++
smith.statements[smith.rnd(len(smith.statements))]()
}
func (smith *Smith) stmtOas() {
list := smith.atypeList(TraitAny)
str, vars := smith.fmtOasVarList(list)
smith.line("%v := %v", str, smith.fmtRvalueList(list))
for _, v := range vars {
smith.defineVar(v.id, v.typ)
}
}
func (smith *Smith) stmtReturn() {
smith.line("return %v", smith.fmtRvalueList(smith.curFunc.rets))
}
func (smith *Smith) stmtAs() {
types := smith.atypeList(TraitAny)
smith.line("%v = %v", smith.fmtLvalueList(types), smith.fmtRvalueList(types))
}
func (smith *Smith) stmtInc() {
smith.line("%v %v", smith.lvalueOrMapIndex(smith.atype(ClassNumeric)), smith.choice("--", "++"))
}
func (smith *Smith) stmtIf() {
smith.enterBlock(true)
smith.enterBlock(true)
if smith.rndBool() {
smith.line("if %v {", smith.rvalue(smith.atype(ClassBoolean)))
} else {
smith.line("if %v; %v {", smith.stmtSimple(true, nil), smith.rvalue(smith.atype(ClassBoolean)))
}
smith.genBlock()
if smith.rndBool() {
smith.line("} else {")
smith.genBlock()
}
smith.leaveBlock()
smith.line("}")
smith.leaveBlock()
}
func (smith *Smith) stmtFor() {
smith.enterBlock(true)
smith.enterBlock(true)
smith.curBlock.isBreakable = true
smith.curBlock.isContinuable = true
var vars []*Var
switch smith.choice("simple", "complex", "range") {
case "simple":
smith.line("for %v {", smith.rvalue(smith.atype(ClassBoolean)))
case "complex":
smith.line("for %v; %v; %v {", smith.stmtSimple(true, nil), smith.rvalue(smith.atype(ClassBoolean)), smith.stmtSimple(false, nil))
case "range":
switch smith.choice("slice", "string", "channel", "map") {
case "slice":
t := smith.atype(TraitAny)
s := smith.rvalue(smith.sliceOf(t))
switch smith.choice("one", "two", "oneDecl", "twoDecl") {
case "one":
smith.line("for %v = range %v {", smith.lvalueOrBlank(smith.intType), s)
case "two":
smith.line("for %v, %v = range %v {", smith.lvalueOrBlank(smith.intType), smith.lvalueOrBlank(t), s)
case "oneDecl":
id := smith.newId("Var")
smith.line("for %v := range %v {", id, s)
vars = append(vars, &Var{id: id, typ: smith.intType})
case "twoDecl":
types := []*Type{smith.intType, t}
str := ""
str, vars = smith.fmtOasVarList(types)
smith.line("for %v := range %v {", str, s)
default:
panic("bad")
}
case "string":
s := smith.rvalue(smith.stringType)
switch smith.choice("one", "two", "oneDecl", "twoDecl") {
case "one":
smith.line("for %v = range %v {", smith.lvalueOrBlank(smith.intType), s)
case "two":
smith.line("for %v, %v = range %v {", smith.lvalueOrBlank(smith.intType), smith.lvalueOrBlank(smith.runeType), s)
case "oneDecl":
id := smith.newId("Var")
smith.line("for %v := range %v {", id, s)
vars = append(vars, &Var{id: id, typ: smith.intType})
case "twoDecl":
types := []*Type{smith.intType, smith.runeType}
str := ""
str, vars = smith.fmtOasVarList(types)
smith.line("for %v := range %v {", str, s)
default:
panic("bad")
}
case "channel":
cht := smith.atype(ClassChan)
ch := smith.rvalue(cht)
switch smith.choice("one", "oneDecl") {
case "one":
smith.line("for %v = range %v {", smith.lvalueOrBlank(cht.ktyp), ch)
case "oneDecl":
id := smith.newId("Var")
smith.line("for %v := range %v {", id, ch)
vars = append(vars, &Var{id: id, typ: cht.ktyp})
default:
panic("bad")
}
case "map":
t := smith.atype(ClassMap)
m := smith.rvalue(t)
switch smith.choice("one", "two", "oneDecl", "twoDecl") {
case "one":
smith.line("for %v = range %v {", smith.lvalueOrBlank(t.ktyp), m)
case "two":
smith.line("for %v, %v = range %v {", smith.lvalueOrBlank(t.ktyp), smith.lvalueOrBlank(t.vtyp), m)
case "oneDecl":
id := smith.newId("Var")
smith.line("for %v := range %v {", id, m)
vars = append(vars, &Var{id: id, typ: t.ktyp})
case "twoDecl":
types := []*Type{t.ktyp, t.vtyp}
str := ""
str, vars = smith.fmtOasVarList(types)
smith.line("for %v := range %v {", str, m)
default:
panic("bad")
}
default:
panic("bad")
}
default:
panic("bad")
}
smith.enterBlock(true)
if len(vars) > 0 {
smith.line("")
for _, v := range vars {
smith.defineVar(v.id, v.typ)
}
}
smith.genBlock()
smith.leaveBlock()
smith.leaveBlock()
smith.line("}")
smith.leaveBlock()
}
func (smith *Smith) stmtSimple(oas bool, newVars *[]*Var) string {
// We emit a fake statement in "oas", so make sure that nothing can be inserted in between.
if smith.curBlock.extendable {
panic("bad")
}
// "send" crashes gccgo with random errors too frequently.
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61273
switch smith.choice("empty", "inc", "assign", "oas", "send", "expr") {
case "empty":
return ""
case "inc":
return F("%v %v", smith.lvalueOrMapIndex(smith.atype(ClassNumeric)), smith.choice("--", "++"))
case "assign":
list := smith.atypeList(TraitAny)
return F("%v = %v", smith.fmtLvalueList(list), smith.fmtRvalueList(list))
case "oas":
if !oas {
return ""
}
list := smith.atypeList(TraitAny)
str, vars := smith.fmtOasVarList(list)
if newVars != nil {
*newVars = vars
}
res := F("%v := %v", str, smith.fmtRvalueList(list))
smith.line("")
for _, v := range vars {
smith.defineVar(v.id, v.typ)
}
return res
case "send":
t := smith.atype(TraitSendable)
return F("%v <- %v", smith.rvalue(t), smith.rvalue(t.ktyp))
case "expr":
return ""
default:
panic("bad")
}
}
func (smith *Smith) stmtSend() {
t := smith.atype(TraitSendable)
smith.line("%v <- %v", smith.rvalue(t), smith.rvalue(t.ktyp))
}
func (smith *Smith) stmtRecv() {
t := smith.atype(TraitReceivable)
ch := smith.rvalue(t)
switch smith.choice("normal", "decl") {
case "normal":
smith.line("%v, %v = <-%v", smith.lvalueOrBlank(t.ktyp), smith.lvalueOrBlank(smith.boolType), ch)
case "decl":
vv := smith.newId("Var")
ok := smith.newId("Var")
smith.line("%v, %v := <-%v", vv, ok, ch)
smith.defineVar(vv, t.ktyp)
smith.defineVar(ok, smith.boolType)
default:
panic("bad")
}
}
func (smith *Smith) stmtTypeDecl() {
id := smith.newId("Type")
t := smith.atype(TraitAny)
smith.line("type %v %v", id, t.id)
newTyp := new(Type)
*newTyp = *t
newTyp.id = id
newTyp.namedUserType = true
if t.class == ClassStruct {
newTyp.literal = func() string {
// replace struct name with new type id
l := t.literal()
l = l[len(t.id)+1:]
return "(" + id + l
}
newTyp.complexLiteral = func() string {
// replace struct name with new type id
l := t.complexLiteral()
l = l[len(t.id)+1:]
return "(" + id + l
}
} else {
newTyp.literal = func() string {
return F("%v(%v)", id, t.literal())
}
if t.complexLiteral != nil {
newTyp.complexLiteral = func() string {
return F("%v(%v)", id, t.complexLiteral())
}
}
}
smith.defineType(newTyp)
}
func (smith *Smith) stmtVarDecl() {
id := smith.newId("Var")
t := smith.atype(TraitAny)
smith.line("var %v %v = %v", id, t.id, smith.rvalue(t))
smith.defineVar(id, t)
}
func (smith *Smith) stmtSelect() {
smith.enterBlock(true)
smith.line("select {")
for smith.rnd(5) != 0 {
smith.enterBlock(true)
elem := smith.atype(TraitAny)
cht := smith.chanOf(elem)
ch := smith.rvalue(cht)
if smith.rndBool() {
smith.line("case %v <- %v:", ch, smith.rvalue(elem))
} else {
switch smith.choice("one", "two", "oneDecl", "twoDecl") {
case "one":
smith.line("case %v = <-%v:", smith.lvalueOrBlank(elem), ch)
case "two":
smith.line("case %v, %v = <-%v:", smith.lvalueOrBlank(elem), smith.lvalueOrBlank(smith.boolType), ch)
case "oneDecl":
vv := smith.newId("Var")
smith.line("case %v := <-%v:", vv, ch)
smith.defineVar(vv, elem)
case "twoDecl":
vv := smith.newId("Var")
ok := smith.newId("Var")
smith.line("case %v, %v := <-%v:", vv, ok, ch)
smith.defineVar(vv, elem)
smith.defineVar(ok, smith.boolType)
default:
panic("bad")
}
}
smith.genBlock()
smith.leaveBlock()
}
if smith.rndBool() {
smith.enterBlock(true)
smith.line("default:")
smith.genBlock()
smith.leaveBlock()
}
smith.line("}")
smith.leaveBlock()
}
func (smith *Smith) stmtSwitchExpr() {
var t *Type
cond := ""
if smith.rndBool() {
t = smith.atype(TraitComparable)
cond = smith.rvalue(t)
} else {
t = smith.boolType
}
smith.enterBlock(true)
smith.enterBlock(true)
smith.curBlock.isBreakable = true
var vars []*Var
if smith.rndBool() {
smith.line("switch %v {", cond)
} else {
smith.line("switch %v; %v {", smith.stmtSimple(true, &vars), cond)
}
// TODO: we generate at most one case, because if we generate more,
// we can generate two cases with equal constants.
fallthru := false
if smith.rndBool() {
smith.enterBlock(true)
smith.line("case %v:", smith.rvalue(t))
smith.genBlock()
smith.leaveBlock()
if smith.rndBool() {
fallthru = true
smith.line("fallthrough")
}
}
if fallthru || len(vars) > 0 || smith.rndBool() {
smith.enterBlock(true)
smith.line("default:")
smith.genBlock()
for _, v := range vars {
smith.line("_ = %v", v.id)
v.used = true
}
smith.leaveBlock()
}
smith.leaveBlock()
smith.line("}")
smith.leaveBlock()
}
func (smith *Smith) stmtSwitchType() {
cond := smith.lvalue(smith.atype(TraitAny))
smith.enterBlock(true)
smith.curBlock.isBreakable = true
smith.line("switch COND := (interface{})(%v); COND.(type) {", cond)
if smith.rndBool() {
smith.enterBlock(true)
smith.line("case %v:", smith.atype(TraitAny).id)
smith.genBlock()
smith.leaveBlock()
}
if smith.rndBool() {
smith.enterBlock(true)
smith.line("default:")
smith.genBlock()
smith.leaveBlock()
}
smith.line("}")
smith.leaveBlock()
}
func (smith *Smith) stmtCall() {
if smith.rndBool() {
smith.stmtCallBuiltin()
}
t := smith.atype(ClassFunction)
prefix := smith.choice("", "go", "defer")
smith.line("%v %v(%v)", prefix, smith.rvalue(t), smith.fmtRvalueList(t.styp))
}
func (smith *Smith) stmtCallBuiltin() {
prefix := smith.choice("", "go", "defer")
switch fn := smith.choice("close", "copy", "delete", "panic", "print", "println", "recover"); fn {
case "close":
smith.line("%v %v(%v)", prefix, fn, smith.rvalue(smith.atype(ClassChan)))
case "copy":
smith.line("%v %v", prefix, smith.exprCopySlice())
case "delete":
t := smith.atype(ClassMap)
smith.line("%v %v(%v, %v)", prefix, fn, smith.rvalue(t), smith.rvalue(t.ktyp))
case "panic":
smith.line("%v %v(%v)", prefix, fn, smith.rvalue(smith.atype(TraitAny)))
case "print":
fallthrough
case "println":
list := smith.atypeList(TraitPrintable)
smith.line("%v %v(%v)", prefix, fn, smith.fmtRvalueList(list))
case "recover":
smith.line("%v %v()", prefix, fn)
default:
panic("bad")
}
}
func (smith *Smith) stmtBreak() {
if !smith.curBlock.isBreakable {
return
}
smith.line("break")
}
func (smith *Smith) stmtContinue() {
if !smith.curBlock.isContinuable {
return
}
smith.line("continue")
}
func (smith *Smith) stmtGoto() {
// TODO: support goto down
id := smith.materializeGotoLabel()
smith.line("goto %v", id)
}
func (smith *Smith) stmtSink() {
// Makes var escape.
smith.line("SINK = %v", smith.exprVar(smith.atype(TraitAny)))
}
go-tools-2021.1.2/internal/gosmith/type.go 0000664 0000000 0000000 00000030775 14143223131 0020306 0 ustar 00root root 0000000 0000000 package main
import (
"bufio"
"bytes"
"fmt"
)
type TypeClass int
const (
ClassBoolean TypeClass = iota
ClassNumeric
ClassComplex
ClassString
ClassArray
ClassSlice
ClassStruct
ClassPointer
ClassFunction
ClassInterface
ClassMap
ClassChan
TraitAny
TraitOrdered
TraitComparable
TraitIndexable
TraitReceivable
TraitSendable
TraitHashable
TraitPrintable
TraitLenCapable
TraitGlobal
)
type Type struct {
id string
class TypeClass
namedUserType bool
ktyp *Type // map key, chan elem, array elem, slice elem, pointee type
vtyp *Type // map val
utyp *Type // underlying type
styp []*Type // function arguments
rtyp []*Type // function return values
elems []*Var // struct fields and interface methods
literal func() string
complexLiteral func() string
// TODO: cache types
// pointerTo *Type
}
func (smith *Smith) initTypes() {
smith.predefinedTypes = []*Type{
{id: "string", class: ClassString, literal: func() string { return "\"foo\"" }},
{id: "bool", class: ClassBoolean, literal: func() string { return "false" }},
{id: "int", class: ClassNumeric, literal: func() string { return "1" }},
{id: "byte", class: ClassNumeric, literal: func() string { return "byte(0)" }},
{id: "interface{}", class: ClassInterface, literal: func() string { return "interface{}(nil)" }},
{id: "rune", class: ClassNumeric, literal: func() string { return "rune(0)" }},
{id: "float32", class: ClassNumeric, literal: func() string { return "float32(1.0)" }},
{id: "float64", class: ClassNumeric, literal: func() string { return "1.0" }},
{id: "complex64", class: ClassComplex, literal: func() string { return "complex64(1i)" }},
{id: "complex128", class: ClassComplex, literal: func() string { return "1i" }},
{id: "uint", class: ClassNumeric, literal: func() string { return "uint(1)" }},
{id: "uintptr", class: ClassNumeric, literal: func() string { return "uintptr(0)" }},
{id: "int16", class: ClassNumeric, literal: func() string { return "int16(1)" }},
{id: "error", class: ClassInterface, literal: func() string { return "error(nil)" }},
}
for _, t := range smith.predefinedTypes {
t.utyp = t
}
smith.stringType = smith.predefinedTypes[0]
smith.boolType = smith.predefinedTypes[1]
smith.intType = smith.predefinedTypes[2]
smith.byteType = smith.predefinedTypes[3]
smith.efaceType = smith.predefinedTypes[4]
smith.runeType = smith.predefinedTypes[5]
smith.float32Type = smith.predefinedTypes[6]
smith.float64Type = smith.predefinedTypes[7]
smith.complex64Type = smith.predefinedTypes[8]
smith.complex128Type = smith.predefinedTypes[9]
smith.stringType.complexLiteral = func() string {
if smith.rndBool() {
return `"ab\x0acd"`
}
return "`abc\\x0acd`"
}
}
func fmtTypeList(list []*Type, parens bool) string {
var buf bytes.Buffer
if parens || len(list) > 1 {
buf.Write([]byte{'('})
}
for i, t := range list {
if i != 0 {
buf.Write([]byte{','})
}
fmt.Fprintf(&buf, "%v", t.id)
}
if parens || len(list) > 1 {
buf.Write([]byte{')'})
}
return buf.String()
}
func (smith *Smith) atype(trait TypeClass) *Type {
smith.typeDepth++
defer func() {
smith.typeDepth--
}()
for {
if smith.typeDepth >= 3 || smith.rndBool() {
var cand []*Type
for _, t := range smith.types() {
if smith.satisfiesTrait(t, trait) {
cand = append(cand, t)
}
}
if len(cand) > 0 {
return cand[smith.rnd(len(cand))]
}
}
t := smith.typeLit()
if t != nil && smith.satisfiesTrait(t, trait) {
return t
}
}
}
func (smith *Smith) typeLit() *Type {
switch smith.choice("array", "chan", "struct", "pointer", "interface", "slice", "function", "map") {
case "array":
return smith.arrayOf(smith.atype(TraitAny))
case "chan":
return smith.chanOf(smith.atype(TraitAny))
case "struct":
var elems []*Var
var buf bytes.Buffer
fmt.Fprintf(&buf, "struct { ")
for smith.rndBool() {
e := &Var{id: smith.newId("Field"), typ: smith.atype(TraitAny)}
elems = append(elems, e)
fmt.Fprintf(&buf, "%v %v\n", e.id, e.typ.id)
}
fmt.Fprintf(&buf, "}")
id := buf.String()
return &Type{
id: id,
class: ClassStruct,
elems: elems,
literal: func() string {
return F("(%v{})", id)
},
complexLiteral: func() string {
if smith.rndBool() {
// unnamed
var buf bytes.Buffer
fmt.Fprintf(&buf, "(%v{", id)
for i := 0; i < len(elems); i++ {
fmt.Fprintf(&buf, "%v, ", smith.rvalue(elems[i].typ))
}
fmt.Fprintf(&buf, "})")
return buf.String()
} else {
// named
var buf bytes.Buffer
fmt.Fprintf(&buf, "(%v{", id)
for i := 0; i < len(elems); i++ {
if smith.rndBool() {
fmt.Fprintf(&buf, "%v: %v, ", elems[i].id, smith.rvalue(elems[i].typ))
}
}
fmt.Fprintf(&buf, "})")
return buf.String()
}
},
}
case "pointer":
return pointerTo(smith.atype(TraitAny))
case "interface":
var buf bytes.Buffer
fmt.Fprintf(&buf, "interface { ")
for smith.rndBool() {
fmt.Fprintf(&buf, " %v %v %v\n", smith.newId("Method"),
fmtTypeList(smith.atypeList(TraitAny), true),
fmtTypeList(smith.atypeList(TraitAny), false))
}
fmt.Fprintf(&buf, "}")
return &Type{
id: buf.String(),
class: ClassInterface,
literal: func() string {
return F("%v(nil)", buf.String())
},
}
case "slice":
return smith.sliceOf(smith.atype(TraitAny))
case "function":
return smith.funcOf(smith.atypeList(TraitAny), smith.atypeList(TraitAny))
case "map":
ktyp := smith.atype(TraitHashable)
vtyp := smith.atype(TraitAny)
return &Type{
id: F("map[%v]%v", ktyp.id, vtyp.id),
class: ClassMap,
ktyp: ktyp,
vtyp: vtyp,
literal: func() string {
if smith.rndBool() {
cap := ""
if smith.rndBool() {
cap = "," + smith.rvalue(smith.intType)
}
return F("make(map[%v]%v %v)", ktyp.id, vtyp.id, cap)
} else {
return F("map[%v]%v{}", ktyp.id, vtyp.id)
}
},
}
default:
panic("bad")
}
}
func (smith *Smith) satisfiesTrait(t *Type, trait TypeClass) bool {
if trait < TraitAny {
return t.class == trait
}
switch trait {
case TraitAny:
return true
case TraitOrdered:
return t.class == ClassNumeric || t.class == ClassString
case TraitComparable:
return t.class == ClassBoolean || t.class == ClassNumeric || t.class == ClassString ||
t.class == ClassPointer || t.class == ClassChan || t.class == ClassInterface
case TraitIndexable:
return t.class == ClassArray || t.class == ClassSlice || t.class == ClassString ||
t.class == ClassMap
case TraitReceivable:
return t.class == ClassChan
case TraitSendable:
return t.class == ClassChan
case TraitHashable:
if t.class == ClassFunction || t.class == ClassMap || t.class == ClassSlice {
return false
}
if t.class == ClassArray && !smith.satisfiesTrait(t.ktyp, TraitHashable) {
return false
}
if t.class == ClassStruct {
for _, e := range t.elems {
if !smith.satisfiesTrait(e.typ, TraitHashable) {
return false
}
}
}
return true
case TraitPrintable:
return t.class == ClassBoolean || t.class == ClassNumeric || t.class == ClassString ||
t.class == ClassPointer || t.class == ClassInterface
case TraitLenCapable:
return t.class == ClassString || t.class == ClassSlice || t.class == ClassArray ||
t.class == ClassMap || t.class == ClassChan
case TraitGlobal:
for _, t1 := range smith.predefinedTypes {
if t == t1 {
return true
}
}
return false
default:
panic("bad")
}
}
func (smith *Smith) atypeList(trait TypeClass) []*Type {
n := smith.rnd(4) + 1
list := make([]*Type, n)
for i := 0; i < n; i++ {
list[i] = smith.atype(trait)
}
return list
}
func typeList(t *Type, n int) []*Type {
list := make([]*Type, n)
for i := 0; i < n; i++ {
list[i] = t
}
return list
}
func pointerTo(elem *Type) *Type {
return &Type{
id: F("*%v", elem.id),
class: ClassPointer,
ktyp: elem,
literal: func() string {
return F("(*%v)(nil)", elem.id)
}}
}
func (smith *Smith) chanOf(elem *Type) *Type {
return &Type{
id: F("chan %v", elem.id),
class: ClassChan,
ktyp: elem,
literal: func() string {
cap := ""
if smith.rndBool() {
cap = "," + smith.rvalue(smith.intType)
}
return F("make(chan %v %v)", elem.id, cap)
},
}
}
func (smith *Smith) sliceOf(elem *Type) *Type {
return &Type{
id: F("[]%v", elem.id),
class: ClassSlice,
ktyp: elem,
literal: func() string {
return F("[]%v{}", elem.id)
},
complexLiteral: func() string {
switch smith.choice("normal", "keyed") {
case "normal":
return F("[]%v{%v}", elem.id, smith.fmtRvalueList(typeList(elem, smith.rnd(3))))
case "keyed":
n := smith.rnd(3)
var indexes []int
loop:
for len(indexes) < n {
i := smith.rnd(10)
for _, i1 := range indexes {
if i1 == i {
continue loop
}
}
indexes = append(indexes, i)
}
var buf bytes.Buffer
fmt.Fprintf(&buf, "[]%v{", elem.id)
for i, idx := range indexes {
if i != 0 {
fmt.Fprintf(&buf, ",")
}
fmt.Fprintf(&buf, "%v: %v", idx, smith.rvalue(elem))
}
fmt.Fprintf(&buf, "}")
return buf.String()
default:
panic("bad")
}
},
}
}
func (smith *Smith) arrayOf(elem *Type) *Type {
size := smith.rnd(3)
return &Type{
id: F("[%v]%v", size, elem.id),
class: ClassArray,
ktyp: elem,
literal: func() string {
return F("[%v]%v{}", size, elem.id)
},
complexLiteral: func() string {
switch smith.choice("normal", "keyed") {
case "normal":
return F("[%v]%v{%v}", smith.choice(F("%v", size), "..."), elem.id, smith.fmtRvalueList(typeList(elem, size)))
case "keyed":
var buf bytes.Buffer
fmt.Fprintf(&buf, "[%v]%v{", size, elem.id)
for i := 0; i < size; i++ {
if i != 0 {
fmt.Fprintf(&buf, ",")
}
fmt.Fprintf(&buf, "%v: %v", i, smith.rvalue(elem))
}
fmt.Fprintf(&buf, "}")
return buf.String()
default:
panic("bad")
}
},
}
}
func (smith *Smith) funcOf(alist, rlist []*Type) *Type {
t := &Type{
id: F("func%v %v", fmtTypeList(alist, true), fmtTypeList(rlist, false)),
class: ClassFunction,
styp: alist,
rtyp: rlist,
}
t.literal = func() string {
return F("((func%v %v)(nil))", fmtTypeList(alist, true), fmtTypeList(rlist, false))
}
t.complexLiteral = func() string {
return smith.genFuncLit(t)
}
return t
}
func (smith *Smith) genFuncLit(ft *Type) string {
//return F("((func%v %v)(nil))", fmtTypeList(ft.styp, true), fmtTypeList(ft.rtyp, false))
if smith.curBlockPos == -1 {
smith.line("")
}
f := &Func{args: ft.styp, rets: ft.rtyp}
curFunc0 := smith.curFunc
smith.curFunc = f
curBlock0 := smith.curBlock
curBlockPos0 := smith.curBlockPos
curBlockLen0 := len(smith.curBlock.sub)
exprDepth0 := smith.exprDepth
exprCount0 := smith.exprCount
smith.exprDepth = 0
smith.exprCount = 0
defer func() {
smith.curBlock = curBlock0
smith.curFunc = curFunc0
smith.exprDepth = exprDepth0
smith.exprCount = exprCount0
smith.curBlockPos = curBlockPos0 + (len(smith.curBlock.sub) - curBlockLen0)
}()
fb := &Block{parent: smith.curBlock, subBlock: smith.curBlock.sub[smith.curBlockPos]}
smith.curBlock = fb
smith.enterBlock(true)
smith.enterBlock(true)
argIds := make([]string, len(f.args))
argStr := ""
for i, a := range f.args {
argIds[i] = smith.newId("Param")
if i != 0 {
argStr += ", "
}
argStr += argIds[i] + " " + a.id
}
smith.line("func(%v)%v {", argStr, fmtTypeList(f.rets, false))
for i, a := range f.args {
smith.defineVar(argIds[i], a)
}
smith.curBlock.funcBoundary = true
smith.genBlock()
smith.leaveBlock()
smith.stmtReturn()
smith.line("}")
smith.leaveBlock()
//b := curBlock.sub[curBlockPos]
//copy(curBlock.sub[curBlockPos:], curBlock.sub[curBlockPos+1:])
//curBlock.sub = curBlock.sub[:len(curBlock.sub)-1]
var buf bytes.Buffer
w := bufio.NewWriter(&buf)
serializeBlock(w, fb, 0)
w.Flush()
s := buf.String()
//fmt.Printf("GEN FUNC:\n%v\n", s)
return s[:len(s)-1]
}
func dependsOn(t, t0 *Type) bool {
if t == nil {
return false
}
if t.class == ClassInterface {
// We don't know how to walk all types referenced by an interface yet.
return true
}
if t0 == nil && t.namedUserType {
return true
}
if t == t0 {
return true
}
if dependsOn(t.ktyp, t0) {
return true
}
if dependsOn(t.vtyp, t0) {
return true
}
if dependsOn(t.ktyp, t0) {
return true
}
for _, t1 := range t.styp {
if dependsOn(t1, t0) {
return true
}
}
for _, t1 := range t.rtyp {
if dependsOn(t1, t0) {
return true
}
}
for _, e := range t.elems {
if dependsOn(e.typ, t0) {
return true
}
}
return false
}
go-tools-2021.1.2/internal/passes/ 0000775 0000000 0000000 00000000000 14143223131 0016606 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/passes/buildir/ 0000775 0000000 0000000 00000000000 14143223131 0020240 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/passes/buildir/buildir.go 0000664 0000000 0000000 00000005663 14143223131 0022233 0 ustar 00root root 0000000 0000000 // 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.
// Package buildir defines an Analyzer that constructs the IR
// of an error-free package and returns the set of all
// functions within it. It does not report any diagnostics itself but
// may be used as an input to other analyzers.
//
// THIS INTERFACE IS EXPERIMENTAL AND MAY BE SUBJECT TO INCOMPATIBLE CHANGE.
package buildir
import (
"go/ast"
"go/types"
"reflect"
"honnef.co/go/tools/go/ir"
"golang.org/x/tools/go/analysis"
)
type noReturn struct {
Kind ir.NoReturn
}
func (*noReturn) AFact() {}
var Analyzer = &analysis.Analyzer{
Name: "buildir",
Doc: "build IR for later passes",
Run: run,
ResultType: reflect.TypeOf(new(IR)),
FactTypes: []analysis.Fact{new(noReturn)},
}
// IR provides intermediate representation for all the
// non-blank source functions in the current package.
type IR struct {
Pkg *ir.Package
SrcFuncs []*ir.Function
}
func run(pass *analysis.Pass) (interface{}, error) {
// Plundered from ssautil.BuildPackage.
// We must create a new Program for each Package because the
// analysis API provides no place to hang a Program shared by
// all Packages. Consequently, IR Packages and Functions do not
// have a canonical representation across an analysis session of
// multiple packages. This is unlikely to be a problem in
// practice because the analysis API essentially forces all
// packages to be analysed independently, so any given call to
// Analysis.Run on a package will see only IR objects belonging
// to a single Program.
mode := ir.GlobalDebug
prog := ir.NewProgram(pass.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
irpkg := prog.CreatePackage(p, nil, nil, true)
for _, fn := range irpkg.Functions {
if ast.IsExported(fn.Name()) {
var noRet noReturn
if pass.ImportObjectFact(fn.Object(), &noRet) {
fn.NoReturn = noRet.Kind
}
}
}
createAll(p.Imports())
}
}
}
createAll(pass.Pkg.Imports())
// Create and build the primary package.
irpkg := prog.CreatePackage(pass.Pkg, pass.Files, pass.TypesInfo, false)
irpkg.Build()
// Compute list of source functions, including literals,
// in source order.
var addAnons func(f *ir.Function)
funcs := make([]*ir.Function, len(irpkg.Functions))
copy(funcs, irpkg.Functions)
addAnons = func(f *ir.Function) {
for _, anon := range f.AnonFuncs {
funcs = append(funcs, anon)
addAnons(anon)
}
}
for _, fn := range irpkg.Functions {
addAnons(fn)
if fn.NoReturn > 0 {
pass.ExportObjectFact(fn.Object(), &noReturn{fn.NoReturn})
}
}
return &IR{Pkg: irpkg, SrcFuncs: funcs}, nil
}
go-tools-2021.1.2/internal/passes/buildir/buildir_test.go 0000664 0000000 0000000 00000001266 14143223131 0023265 0 ustar 00root root 0000000 0000000 // 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.
package buildir_test
import (
"fmt"
"os"
"testing"
"golang.org/x/tools/go/analysis/analysistest"
"honnef.co/go/tools/internal/passes/buildir"
)
func Test(t *testing.T) {
testdata := analysistest.TestData()
result := analysistest.Run(t, testdata, buildir.Analyzer, "a")[0].Result
irinfo := result.(*buildir.IR)
got := fmt.Sprint(irinfo.SrcFuncs)
want := `[a.init a.Fib (a.T).fib]`
if got != want {
t.Errorf("IR.SrcFuncs = %s, want %s", got, want)
for _, f := range irinfo.SrcFuncs {
f.WriteTo(os.Stderr)
}
}
}
go-tools-2021.1.2/internal/passes/buildir/testdata/ 0000775 0000000 0000000 00000000000 14143223131 0022051 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/passes/buildir/testdata/src/ 0000775 0000000 0000000 00000000000 14143223131 0022640 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/passes/buildir/testdata/src/a/ 0000775 0000000 0000000 00000000000 14143223131 0023060 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/passes/buildir/testdata/src/a/a.go 0000664 0000000 0000000 00000000253 14143223131 0023627 0 ustar 00root root 0000000 0000000 package a
func Fib(x int) int {
if x < 2 {
return x
}
return Fib(x-1) + Fib(x-2)
}
type T int
func (T) fib(x int) int { return Fib(x) }
func _() {
print("hi")
}
go-tools-2021.1.2/internal/renameio/ 0000775 0000000 0000000 00000000000 14143223131 0017107 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/renameio/UPSTREAM 0000664 0000000 0000000 00000000243 14143223131 0020271 0 ustar 00root root 0000000 0000000 This package is a copy of cmd/go/internal/renameio.
The upstream package no longer exists, as the Go project replaced all of its uses with the lockedfile package.
go-tools-2021.1.2/internal/renameio/renameio.go 0000664 0000000 0000000 00000005526 14143223131 0021245 0 ustar 00root root 0000000 0000000 // 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.
// Package renameio writes files atomically by renaming temporary files.
package renameio
import (
"bytes"
"io"
"math/rand"
"os"
"path/filepath"
"strconv"
"honnef.co/go/tools/internal/robustio"
)
const patternSuffix = ".tmp"
// Pattern returns a glob pattern that matches the unrenamed temporary files
// created when writing to filename.
func Pattern(filename string) string {
return filepath.Join(filepath.Dir(filename), filepath.Base(filename)+patternSuffix)
}
// WriteFile is like ioutil.WriteFile, but first writes data to an arbitrary
// file in the same directory as filename, then renames it atomically to the
// final name.
//
// That ensures that the final location, if it exists, is always a complete file.
func WriteFile(filename string, data []byte, perm os.FileMode) (err error) {
return WriteToFile(filename, bytes.NewReader(data), perm)
}
// WriteToFile is a variant of WriteFile that accepts the data as an io.Reader
// instead of a slice.
func WriteToFile(filename string, data io.Reader, perm os.FileMode) (err error) {
f, err := tempFile(filepath.Dir(filename), filepath.Base(filename), perm)
if err != nil {
return err
}
defer func() {
// Only call os.Remove on f.Name() if we failed to rename it: otherwise,
// some other process may have created a new file with the same name after
// that.
if err != nil {
f.Close()
os.Remove(f.Name())
}
}()
if _, err := io.Copy(f, data); err != nil {
return err
}
// Sync the file before renaming it: otherwise, after a crash the reader may
// observe a 0-length file instead of the actual contents.
// See https://golang.org/issue/22397#issuecomment-380831736.
if err := f.Sync(); err != nil {
return err
}
if err := f.Close(); err != nil {
return err
}
return robustio.Rename(f.Name(), filename)
}
// ReadFile is like ioutil.ReadFile, but on Windows retries spurious errors that
// may occur if the file is concurrently replaced.
//
// Errors are classified heuristically and retries are bounded, so even this
// function may occasionally return a spurious error on Windows.
// If so, the error will likely wrap one of:
// - syscall.ERROR_ACCESS_DENIED
// - syscall.ERROR_FILE_NOT_FOUND
// - internal/syscall/windows.ERROR_SHARING_VIOLATION
func ReadFile(filename string) ([]byte, error) {
return robustio.ReadFile(filename)
}
// tempFile creates a new temporary file with given permission bits.
func tempFile(dir, prefix string, perm os.FileMode) (f *os.File, err error) {
for i := 0; i < 10000; i++ {
name := filepath.Join(dir, prefix+strconv.Itoa(rand.Intn(1000000000))+patternSuffix)
f, err = os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, perm)
if os.IsExist(err) {
continue
}
break
}
return
}
go-tools-2021.1.2/internal/renameio/renameio_test.go 0000664 0000000 0000000 00000007553 14143223131 0022306 0 ustar 00root root 0000000 0000000 // Copyright 2019 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.
// +build !plan9
package renameio
import (
"encoding/binary"
"errors"
"io/ioutil"
"math/rand"
"os"
"path/filepath"
"runtime"
"sync"
"sync/atomic"
"syscall"
"testing"
"time"
"honnef.co/go/tools/internal/robustio"
)
func TestConcurrentReadsAndWrites(t *testing.T) {
dir, err := ioutil.TempDir("", "renameio")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(dir)
path := filepath.Join(dir, "blob.bin")
const chunkWords = 8 << 10
buf := make([]byte, 2*chunkWords*8)
for i := uint64(0); i < 2*chunkWords; i++ {
binary.LittleEndian.PutUint64(buf[i*8:], i)
}
var attempts int64 = 128
if !testing.Short() {
attempts *= 16
}
const parallel = 32
var sem = make(chan bool, parallel)
var (
writeSuccesses, readSuccesses int64 // atomic
writeErrnoSeen, readErrnoSeen sync.Map
)
for n := attempts; n > 0; n-- {
sem <- true
go func() {
defer func() { <-sem }()
time.Sleep(time.Duration(rand.Intn(100)) * time.Microsecond)
offset := rand.Intn(chunkWords)
chunk := buf[offset*8 : (offset+chunkWords)*8]
if err := WriteFile(path, chunk, 0666); err == nil {
atomic.AddInt64(&writeSuccesses, 1)
} else if robustio.IsEphemeralError(err) {
var (
errno syscall.Errno
dup bool
)
if errors.As(err, &errno) {
_, dup = writeErrnoSeen.LoadOrStore(errno, true)
}
if !dup {
t.Logf("ephemeral error: %v", err)
}
} else {
t.Errorf("unexpected error: %v", err)
}
time.Sleep(time.Duration(rand.Intn(100)) * time.Microsecond)
data, err := ReadFile(path)
if err == nil {
atomic.AddInt64(&readSuccesses, 1)
} else if robustio.IsEphemeralError(err) {
var (
errno syscall.Errno
dup bool
)
if errors.As(err, &errno) {
_, dup = readErrnoSeen.LoadOrStore(errno, true)
}
if !dup {
t.Logf("ephemeral error: %v", err)
}
return
} else {
t.Errorf("unexpected error: %v", err)
return
}
if len(data) != 8*chunkWords {
t.Errorf("read %d bytes, but each write is a %d-byte file", len(data), 8*chunkWords)
return
}
u := binary.LittleEndian.Uint64(data)
for i := 1; i < chunkWords; i++ {
next := binary.LittleEndian.Uint64(data[i*8:])
if next != u+1 {
t.Errorf("wrote sequential integers, but read integer out of sequence at offset %d", i)
return
}
u = next
}
}()
}
for n := parallel; n > 0; n-- {
sem <- true
}
var minWriteSuccesses int64 = attempts
if runtime.GOOS == "windows" {
// Windows produces frequent "Access is denied" errors under heavy rename load.
// As long as those are the only errors and *some* of the writes succeed, we're happy.
minWriteSuccesses = attempts / 4
}
if writeSuccesses < minWriteSuccesses {
t.Errorf("%d (of %d) writes succeeded; want β₯ %d", writeSuccesses, attempts, minWriteSuccesses)
} else {
t.Logf("%d (of %d) writes succeeded (ok: β₯ %d)", writeSuccesses, attempts, minWriteSuccesses)
}
var minReadSuccesses int64 = attempts
switch runtime.GOOS {
case "windows":
// Windows produces frequent "Access is denied" errors under heavy rename load.
// As long as those are the only errors and *some* of the reads succeed, we're happy.
minReadSuccesses = attempts / 4
case "darwin":
// The filesystem on macOS 10.14 occasionally fails with "no such file or
// directory" errors. See https://golang.org/issue/33041. The flake rate is
// fairly low, so ensure that at least 75% of attempts succeed.
minReadSuccesses = attempts - (attempts / 4)
}
if readSuccesses < minReadSuccesses {
t.Errorf("%d (of %d) reads succeeded; want β₯ %d", readSuccesses, attempts, minReadSuccesses)
} else {
t.Logf("%d (of %d) reads succeeded (ok: β₯ %d)", readSuccesses, attempts, minReadSuccesses)
}
}
go-tools-2021.1.2/internal/renameio/umask_test.go 0000664 0000000 0000000 00000001664 14143223131 0021624 0 ustar 00root root 0000000 0000000 // Copyright 2019 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.
// +build !plan9,!windows,!js
package renameio
import (
"io/ioutil"
"os"
"path/filepath"
"syscall"
"testing"
)
func TestWriteFileModeAppliesUmask(t *testing.T) {
dir, err := ioutil.TempDir("", "renameio")
if err != nil {
t.Fatalf("Failed to create temporary directory: %v", err)
}
defer os.RemoveAll(dir)
const mode = 0644
const umask = 0007
defer syscall.Umask(syscall.Umask(umask))
file := filepath.Join(dir, "testWrite")
err = WriteFile(file, []byte("go-build"), mode)
if err != nil {
t.Fatalf("Failed to write file: %v", err)
}
fi, err := os.Stat(file)
if err != nil {
t.Fatalf("Stat %q (looking for mode %#o): %s", file, mode, err)
}
if fi.Mode()&os.ModePerm != 0640 {
t.Errorf("Stat %q: mode %#o want %#o", file, fi.Mode()&os.ModePerm, 0640)
}
}
go-tools-2021.1.2/internal/robustio/ 0000775 0000000 0000000 00000000000 14143223131 0017156 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/robustio/UPSTREAM 0000664 0000000 0000000 00000000457 14143223131 0020347 0 ustar 00root root 0000000 0000000 This package is a copy of cmd/go/internal/robustio.
It is mostly in sync with upstream according to the last commit we've looked at,
with the exception of still using I/O functions that work with older Go versions.
The last upstream commit we've looked at was:
06ac303f6a14b133254f757e54599c48e3c2a4ad
go-tools-2021.1.2/internal/robustio/robustio.go 0000664 0000000 0000000 00000003706 14143223131 0021361 0 ustar 00root root 0000000 0000000 // Copyright 2019 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 robustio wraps I/O functions that are prone to failure on Windows,
// transparently retrying errors up to an arbitrary timeout.
//
// Errors are classified heuristically and retries are bounded, so the functions
// in this package do not completely eliminate spurious errors. However, they do
// significantly reduce the rate of failure in practice.
//
// If so, the error will likely wrap one of:
// The functions in this package do not completely eliminate spurious errors,
// but substantially reduce their rate of occurrence in practice.
package robustio
// Rename is like os.Rename, but on Windows retries errors that may occur if the
// file is concurrently read or overwritten.
//
// (See golang.org/issue/31247 and golang.org/issue/32188.)
func Rename(oldpath, newpath string) error {
return rename(oldpath, newpath)
}
// ReadFile is like ioutil.ReadFile, but on Windows retries errors that may
// occur if the file is concurrently replaced.
//
// (See golang.org/issue/31247 and golang.org/issue/32188.)
func ReadFile(filename string) ([]byte, error) {
return readFile(filename)
}
// RemoveAll is like os.RemoveAll, but on Windows retries errors that may occur
// if an executable file in the directory has recently been executed.
//
// (See golang.org/issue/19491.)
func RemoveAll(path string) error {
return removeAll(path)
}
// IsEphemeralError reports whether err is one of the errors that the functions
// in this package attempt to mitigate.
//
// Errors considered ephemeral include:
// - syscall.ERROR_ACCESS_DENIED
// - syscall.ERROR_FILE_NOT_FOUND
// - internal/syscall/windows.ERROR_SHARING_VIOLATION
//
// This set may be expanded in the future; programs must not rely on the
// non-ephemerality of any given error.
func IsEphemeralError(err error) bool {
return isEphemeralError(err)
}
go-tools-2021.1.2/internal/robustio/robustio_darwin.go 0000664 0000000 0000000 00000000722 14143223131 0022720 0 ustar 00root root 0000000 0000000 // Copyright 2019 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 robustio
import (
"errors"
"syscall"
)
const errFileNotFound = syscall.ENOENT
// isEphemeralError returns true if err may be resolved by waiting.
func isEphemeralError(err error) bool {
var errno syscall.Errno
if errors.As(err, &errno) {
return errno == errFileNotFound
}
return false
}
go-tools-2021.1.2/internal/robustio/robustio_flaky.go 0000664 0000000 0000000 00000004775 14143223131 0022556 0 ustar 00root root 0000000 0000000 // Copyright 2019 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.
// +build windows darwin
package robustio
import (
"errors"
"io/ioutil"
"math/rand"
"os"
"syscall"
"time"
)
const arbitraryTimeout = 2000 * time.Millisecond
// retry retries ephemeral errors from f up to an arbitrary timeout
// to work around filesystem flakiness on Windows and Darwin.
func retry(f func() (err error, mayRetry bool)) error {
var (
bestErr error
lowestErrno syscall.Errno
start time.Time
nextSleep time.Duration = 1 * time.Millisecond
)
for {
err, mayRetry := f()
if err == nil || !mayRetry {
return err
}
var errno syscall.Errno
if errors.As(err, &errno) && (lowestErrno == 0 || errno < lowestErrno) {
bestErr = err
lowestErrno = errno
} else if bestErr == nil {
bestErr = err
}
if start.IsZero() {
start = time.Now()
} else if d := time.Since(start) + nextSleep; d >= arbitraryTimeout {
break
}
time.Sleep(nextSleep)
nextSleep += time.Duration(rand.Int63n(int64(nextSleep)))
}
return bestErr
}
// rename is like os.Rename, but retries ephemeral errors.
//
// On Windows it wraps os.Rename, which (as of 2019-06-04) uses MoveFileEx with
// MOVEFILE_REPLACE_EXISTING.
//
// Windows also provides a different system call, ReplaceFile,
// that provides similar semantics, but perhaps preserves more metadata. (The
// documentation on the differences between the two is very sparse.)
//
// Empirical error rates with MoveFileEx are lower under modest concurrency, so
// for now we're sticking with what the os package already provides.
func rename(oldpath, newpath string) (err error) {
return retry(func() (err error, mayRetry bool) {
err = os.Rename(oldpath, newpath)
return err, isEphemeralError(err)
})
}
// readFile is like ioutil.ReadFile, but retries ephemeral errors.
func readFile(filename string) ([]byte, error) {
var b []byte
err := retry(func() (err error, mayRetry bool) {
b, err = ioutil.ReadFile(filename)
// Unlike in rename, we do not retry errFileNotFound here: it can occur
// as a spurious error, but the file may also genuinely not exist, so the
// increase in robustness is probably not worth the extra latency.
return err, isEphemeralError(err) && !errors.Is(err, errFileNotFound)
})
return b, err
}
func removeAll(path string) error {
return retry(func() (err error, mayRetry bool) {
err = os.RemoveAll(path)
return err, isEphemeralError(err)
})
}
go-tools-2021.1.2/internal/robustio/robustio_other.go 0000664 0000000 0000000 00000001021 14143223131 0022546 0 ustar 00root root 0000000 0000000 // Copyright 2019 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.
// +build !windows,!darwin
package robustio
import (
"io/ioutil"
"os"
)
func rename(oldpath, newpath string) error {
return os.Rename(oldpath, newpath)
}
func readFile(filename string) ([]byte, error) {
return ioutil.ReadFile(filename)
}
func removeAll(path string) error {
return os.RemoveAll(path)
}
func isEphemeralError(err error) bool {
return false
}
go-tools-2021.1.2/internal/robustio/robustio_windows.go 0000664 0000000 0000000 00000001146 14143223131 0023127 0 ustar 00root root 0000000 0000000 // Copyright 2019 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 robustio
import (
"errors"
"syscall"
)
const ERROR_SHARING_VIOLATION = 32
const errFileNotFound = syscall.ERROR_FILE_NOT_FOUND
// isEphemeralError returns true if err may be resolved by waiting.
func isEphemeralError(err error) bool {
var errno syscall.Errno
if errors.As(err, &errno) {
switch errno {
case syscall.ERROR_ACCESS_DENIED,
syscall.ERROR_FILE_NOT_FOUND,
ERROR_SHARING_VIOLATION:
return true
}
}
return false
}
go-tools-2021.1.2/internal/sharedcheck/ 0000775 0000000 0000000 00000000000 14143223131 0017554 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/sharedcheck/lint.go 0000664 0000000 0000000 00000015132 14143223131 0021053 0 ustar 00root root 0000000 0000000 package sharedcheck
import (
"fmt"
"go/ast"
"go/token"
"go/types"
"honnef.co/go/tools/analysis/code"
"honnef.co/go/tools/analysis/edit"
"honnef.co/go/tools/analysis/facts"
"honnef.co/go/tools/analysis/report"
"honnef.co/go/tools/go/ast/astutil"
"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"
"golang.org/x/tools/go/analysis/passes/inspect"
)
func CheckRangeStringRunes(pass *analysis.Pass) (interface{}, error) {
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
cb := func(node ast.Node) bool {
rng, ok := node.(*ast.RangeStmt)
if !ok || !astutil.IsBlank(rng.Key) {
return true
}
v, _ := fn.ValueForExpr(rng.X)
// Check that we're converting from string to []rune
val, _ := v.(*ir.Convert)
if val == nil {
return true
}
Tsrc, ok := val.X.Type().Underlying().(*types.Basic)
if !ok || Tsrc.Kind() != types.String {
return true
}
Tdst, ok := val.Type().(*types.Slice)
if !ok {
return true
}
TdstElem, ok := Tdst.Elem().(*types.Basic)
if !ok || TdstElem.Kind() != types.Int32 {
return true
}
// Check that the result of the conversion is only used to
// range over
refs := val.Referrers()
if refs == nil {
return true
}
// Expect two refs: one for obtaining the length of the slice,
// one for accessing the elements
if len(irutil.FilterDebug(*refs)) != 2 {
// TODO(dh): right now, we check that only one place
// refers to our slice. This will miss cases such as
// ranging over the slice twice. Ideally, we'd ensure that
// the slice is only used for ranging over (without
// accessing the key), but that is harder to do because in
// IR form, ranging over a slice looks like an ordinary
// loop with index increments and slice accesses. We'd
// have to look at the associated AST node to check that
// it's a range statement.
return true
}
pass.Reportf(rng.Pos(), "should range over string, not []rune(string)")
return true
}
if source := fn.Source(); source != nil {
ast.Inspect(source, cb)
}
}
return nil, nil
}
// RedundantTypeInDeclarationChecker returns a checker that flags variable declarations with redundantly specified types.
// That is, it flags 'var v T = e' where e's type is identical to T and 'var v = e' (or 'v := e') would have the same effect.
//
// It does not flag variables under the following conditions, to reduce the number of false positives:
// - global variables β these often specify types to aid godoc
// - files that use cgo β cgo code generation and pointer checking emits redundant types
//
// It does not flag variables under the following conditions, unless flagHelpfulTypes is true, to reduce the number of noisy positives:
// - packages that import syscall or unsafe β these sometimes use this form of assignment to make sure types are as expected
// - variables named the blank identifier β a pattern used to confirm the types of variables
// - named untyped constants on the rhs β the explicitness might aid readability
func RedundantTypeInDeclarationChecker(verb string, flagHelpfulTypes bool) *analysis.Analyzer {
fn := func(pass *analysis.Pass) (interface{}, error) {
eval := func(expr ast.Expr) (types.TypeAndValue, error) {
info := &types.Info{
Types: map[ast.Expr]types.TypeAndValue{},
}
err := types.CheckExpr(pass.Fset, pass.Pkg, expr.Pos(), expr, info)
return info.Types[expr], err
}
if !flagHelpfulTypes {
// Don't look at code in low-level packages
for _, imp := range pass.Pkg.Imports() {
if imp.Path() == "syscall" || imp.Path() == "unsafe" {
return nil, nil
}
}
}
fn := func(node ast.Node) {
decl := node.(*ast.GenDecl)
if decl.Tok != token.VAR {
return
}
gen, _ := code.Generator(pass, decl.Pos())
if gen == facts.Cgo {
// TODO(dh): remove this exception once we can use UsesCgo
return
}
// Delay looking up parent AST nodes until we have to
checkedDecl := false
specLoop:
for _, spec := range decl.Specs {
spec := spec.(*ast.ValueSpec)
if spec.Type == nil {
continue
}
if len(spec.Names) != len(spec.Values) {
continue
}
Tlhs := pass.TypesInfo.TypeOf(spec.Type)
for i, v := range spec.Values {
if !flagHelpfulTypes && spec.Names[i].Name == "_" {
continue specLoop
}
Trhs := pass.TypesInfo.TypeOf(v)
if !types.Identical(Tlhs, Trhs) {
continue specLoop
}
// Some expressions are untyped and get converted to the lhs type implicitly.
// This applies to untyped constants, shift operations with an untyped lhs, and possibly others.
//
// Check if the type is truly redundant, i.e. if the type on the lhs doesn't match the default type of the untyped constant.
tv, err := eval(v)
if err != nil {
panic(err)
}
if b, ok := tv.Type.(*types.Basic); ok && (b.Info()&types.IsUntyped) != 0 {
switch v := v.(type) {
case *ast.Ident:
// Only flag named constant rhs if it's a predeclared identifier.
// Don't flag other named constants, as the explicit type may aid readability.
if pass.TypesInfo.ObjectOf(v).Pkg() != nil && !flagHelpfulTypes {
continue specLoop
}
case *ast.SelectorExpr:
// Constant selector expressions can only refer to named constants that arent predeclared.
if !flagHelpfulTypes {
continue specLoop
}
default:
// don't skip if the type on the lhs matches the default type of the constant
if Tlhs != types.Default(b) {
continue specLoop
}
}
}
}
if !checkedDecl {
// Don't flag global variables. These often have explicit types for godoc's sake.
path, _ := astutil.PathEnclosingInterval(code.File(pass, decl), decl.Pos(), decl.Pos())
pathLoop:
for _, el := range path {
switch el.(type) {
case *ast.FuncDecl, *ast.FuncLit:
checkedDecl = true
break pathLoop
}
}
if !checkedDecl {
// decl is not inside a function
break specLoop
}
}
report.Report(pass, spec.Type, fmt.Sprintf("%s omit type %s from declaration; it will be inferred from the right-hand side", verb, report.Render(pass, spec.Type)), report.FilterGenerated(),
report.Fixes(edit.Fix("Remove redundant type", edit.Delete(spec.Type))))
}
}
code.Preorder(pass, fn, (*ast.GenDecl)(nil))
return nil, nil
}
return &analysis.Analyzer{
Run: fn,
Requires: []*analysis.Analyzer{facts.Generated, inspect.Analyzer, facts.TokenFile, facts.Generated},
}
}
go-tools-2021.1.2/internal/sync/ 0000775 0000000 0000000 00000000000 14143223131 0016264 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/sync/sync.go 0000664 0000000 0000000 00000000762 14143223131 0017574 0 ustar 00root root 0000000 0000000 package sync
type Semaphore struct {
ch chan struct{}
}
func NewSemaphore(size int) Semaphore {
return Semaphore{
ch: make(chan struct{}, size),
}
}
func (sem Semaphore) Acquire() {
sem.ch <- struct{}{}
}
func (sem Semaphore) AcquireMaybe() bool {
select {
case sem.ch <- struct{}{}:
return true
default:
return false
}
}
func (sem Semaphore) Release() {
<-sem.ch
}
func (sem Semaphore) Len() int {
return len(sem.ch)
}
func (sem Semaphore) Cap() int {
return cap(sem.ch)
}
go-tools-2021.1.2/internal/testenv/ 0000775 0000000 0000000 00000000000 14143223131 0017000 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/internal/testenv/testenv.go 0000664 0000000 0000000 00000011240 14143223131 0021015 0 ustar 00root root 0000000 0000000 // Copyright 2019 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 testenv contains helper functions for skipping tests
// based on which tools are present in the environment.
package testenv
import (
"fmt"
"io/ioutil"
"os"
"os/exec"
"runtime"
"strings"
"sync"
)
// Testing is an abstraction of a *testing.T.
type Testing interface {
Skipf(format string, args ...interface{})
Fatalf(format string, args ...interface{})
}
type helperer interface {
Helper()
}
// packageMainIsDevel reports whether the module containing package main
// is a development version (if module information is available).
//
// Builds in GOPATH mode and builds that lack module information are assumed to
// be development versions.
var packageMainIsDevel = func() bool { return true }
var checkGoGoroot struct {
once sync.Once
err error
}
func hasTool(tool string) error {
_, err := exec.LookPath(tool)
if err != nil {
return err
}
switch tool {
case "patch":
// check that the patch tools supports the -o argument
temp, err := ioutil.TempFile("", "patch-test")
if err != nil {
return err
}
temp.Close()
defer os.Remove(temp.Name())
cmd := exec.Command(tool, "-o", temp.Name())
if err := cmd.Run(); err != nil {
return err
}
case "go":
checkGoGoroot.once.Do(func() {
// Ensure that the 'go' command found by exec.LookPath is from the correct
// GOROOT. Otherwise, 'some/path/go test ./...' will test against some
// version of the 'go' binary other than 'some/path/go', which is almost
// certainly not what the user intended.
out, err := exec.Command(tool, "env", "GOROOT").CombinedOutput()
if err != nil {
checkGoGoroot.err = err
return
}
GOROOT := strings.TrimSpace(string(out))
if GOROOT != runtime.GOROOT() {
checkGoGoroot.err = fmt.Errorf("'go env GOROOT' does not match runtime.GOROOT:\n\tgo env: %s\n\tGOROOT: %s", GOROOT, runtime.GOROOT())
}
})
if checkGoGoroot.err != nil {
return checkGoGoroot.err
}
}
return nil
}
func allowMissingTool(tool string) bool {
if runtime.GOOS == "android" {
// Android builds generally run tests on a separate machine from the build,
// so don't expect any external tools to be available.
return true
}
switch tool {
case "go":
if os.Getenv("GO_BUILDER_NAME") == "illumos-amd64-joyent" {
// Work around a misconfigured builder (see https://golang.org/issue/33950).
return true
}
case "diff":
if os.Getenv("GO_BUILDER_NAME") != "" {
return true
}
case "patch":
if os.Getenv("GO_BUILDER_NAME") != "" {
return true
}
}
// If a developer is actively working on this test, we expect them to have all
// of its dependencies installed. However, if it's just a dependency of some
// other module (for example, being run via 'go test all'), we should be more
// tolerant of unusual environments.
return !packageMainIsDevel()
}
// NeedsTool skips t if the named tool is not present in the path.
func NeedsTool(t Testing, tool string) {
if t, ok := t.(helperer); ok {
t.Helper()
}
err := hasTool(tool)
if err == nil {
return
}
if allowMissingTool(tool) {
t.Skipf("skipping because %s tool not available: %v", tool, err)
} else {
t.Fatalf("%s tool not available: %v", tool, err)
}
}
// NeedsGoPackages skips t if the go/packages driver (or 'go' tool) implied by
// the current process environment is not present in the path.
func NeedsGoPackages(t Testing) {
if t, ok := t.(helperer); ok {
t.Helper()
}
tool := os.Getenv("GOPACKAGESDRIVER")
switch tool {
case "off":
// "off" forces go/packages to use the go command.
tool = "go"
case "":
if _, err := exec.LookPath("gopackagesdriver"); err == nil {
tool = "gopackagesdriver"
} else {
tool = "go"
}
}
NeedsTool(t, tool)
}
// NeedsGoPackagesEnv skips t if the go/packages driver (or 'go' tool) implied
// by env is not present in the path.
func NeedsGoPackagesEnv(t Testing, env []string) {
if t, ok := t.(helperer); ok {
t.Helper()
}
for _, v := range env {
if strings.HasPrefix(v, "GOPACKAGESDRIVER=") {
tool := strings.TrimPrefix(v, "GOPACKAGESDRIVER=")
if tool == "off" {
NeedsTool(t, "go")
} else {
NeedsTool(t, tool)
}
return
}
}
NeedsGoPackages(t)
}
// ExitIfSmallMachine emits a helpful diagnostic and calls os.Exit(0) if the
// current machine is a builder known to have scarce resources.
//
// It should be called from within a TestMain function.
func ExitIfSmallMachine() {
if os.Getenv("GO_BUILDER_NAME") == "linux-arm" {
fmt.Fprintln(os.Stderr, "skipping test: linux-arm builder lacks sufficient memory (https://golang.org/issue/32834)")
os.Exit(0)
}
}
go-tools-2021.1.2/internal/testenv/testenv_112.go 0000664 0000000 0000000 00000001346 14143223131 0021406 0 ustar 00root root 0000000 0000000 // Copyright 2019 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.
// +build go1.12
package testenv
import "runtime/debug"
func packageMainIsDevelModule() bool {
info, ok := debug.ReadBuildInfo()
if !ok {
// Most test binaries currently lack build info, but this should become more
// permissive once https://golang.org/issue/33976 is fixed.
return true
}
// Note: info.Main.Version describes the version of the module containing
// package main, not the version of βthe main moduleβ.
// See https://golang.org/issue/33975.
return info.Main.Version == "(devel)"
}
func init() {
packageMainIsDevel = packageMainIsDevelModule
}
go-tools-2021.1.2/knowledge/ 0000775 0000000 0000000 00000000000 14143223131 0015453 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/knowledge/arg.go 0000664 0000000 0000000 00000004617 14143223131 0016563 0 ustar 00root root 0000000 0000000 package knowledge
var args = map[string]int{
"(*encoding/json.Decoder).Decode.v": 0,
"(*encoding/json.Encoder).Encode.v": 0,
"(*encoding/xml.Decoder).Decode.v": 0,
"(*encoding/xml.Encoder).Encode.v": 0,
"(*sync.Pool).Put.x": 0,
"(*text/template.Template).Parse.text": 0,
"(io.Seeker).Seek.offset": 0,
"(time.Time).Sub.u": 0,
"append.elems": 1,
"append.slice": 0,
"bytes.Equal.a": 0,
"bytes.Equal.b": 1,
"encoding/binary.Write.data": 2,
"errors.New.text": 0,
"fmt.Fprintf.format": 1,
"fmt.Printf.format": 0,
"fmt.Sprintf.a[0]": 1,
"fmt.Sprintf.format": 0,
"json.Marshal.v": 0,
"json.Unmarshal.v": 1,
"len.v": 0,
"make.size[0]": 1,
"make.size[1]": 2,
"make.t": 0,
"net/url.Parse.rawurl": 0,
"os.OpenFile.flag": 1,
"os/exec.Command.name": 0,
"os/signal.Notify.c": 0,
"regexp.Compile.expr": 0,
"runtime.SetFinalizer.finalizer": 1,
"runtime.SetFinalizer.obj": 0,
"sort.Sort.data": 0,
"strconv.AppendFloat.bitSize": 4,
"strconv.AppendFloat.fmt": 2,
"strconv.AppendInt.base": 2,
"strconv.AppendUint.base": 2,
"strconv.FormatComplex.bitSize": 3,
"strconv.FormatComplex.fmt": 1,
"strconv.FormatFloat.bitSize": 3,
"strconv.FormatFloat.fmt": 1,
"strconv.FormatInt.base": 1,
"strconv.FormatUint.base": 1,
"strconv.ParseComplex.bitSize": 1,
"strconv.ParseFloat.bitSize": 1,
"strconv.ParseInt.base": 1,
"strconv.ParseInt.bitSize": 2,
"strconv.ParseUint.base": 1,
"strconv.ParseUint.bitSize": 2,
"time.Parse.layout": 0,
"time.Sleep.d": 0,
"xml.Marshal.v": 0,
"xml.Unmarshal.v": 1,
}
func Arg(name string) int {
n, ok := args[name]
if !ok {
panic("unknown argument " + name)
}
return n
}
go-tools-2021.1.2/knowledge/deprecated.go 0000664 0000000 0000000 00000024150 14143223131 0020104 0 ustar 00root root 0000000 0000000 package knowledge
const (
DeprecatedNeverUse = -1
DeprecatedUseNoLonger = -2
)
type Deprecation struct {
DeprecatedSince int
AlternativeAvailableSince int
}
// go/importer.ForCompiler contains "Deprecated:", but it refers to a single argument, not the whole function.
// Luckily, the notice starts in the middle of a paragraph, and as such isn't detected by us.
var StdlibDeprecations = map[string]Deprecation{
// FIXME(dh): AllowBinary isn't being detected as deprecated
// because the comment has a newline right after "Deprecated:"
"go/build.AllowBinary": {7, 7},
"(archive/zip.FileHeader).CompressedSize": {1, 1},
"(archive/zip.FileHeader).UncompressedSize": {1, 1},
"(archive/zip.FileHeader).ModifiedTime": {10, 10},
"(archive/zip.FileHeader).ModifiedDate": {10, 10},
"(*archive/zip.FileHeader).ModTime": {10, 10},
"(*archive/zip.FileHeader).SetModTime": {10, 10},
"(go/doc.Package).Bugs": {1, 1},
"os.SEEK_SET": {7, 7},
"os.SEEK_CUR": {7, 7},
"os.SEEK_END": {7, 7},
"(net.Dialer).Cancel": {7, 7},
"runtime.CPUProfile": {9, 0},
"compress/flate.ReadError": {6, DeprecatedUseNoLonger},
"compress/flate.WriteError": {6, DeprecatedUseNoLonger},
"path/filepath.HasPrefix": {0, DeprecatedNeverUse},
"(net/http.Transport).Dial": {7, 7},
"(net/http.Transport).DialTLS": {14, 14},
"(*net/http.Transport).CancelRequest": {6, 5},
"net/http.ErrWriteAfterFlush": {7, DeprecatedUseNoLonger},
"net/http.ErrHeaderTooLong": {8, DeprecatedUseNoLonger},
"net/http.ErrShortBody": {8, DeprecatedUseNoLonger},
"net/http.ErrMissingContentLength": {8, DeprecatedUseNoLonger},
"net/http/httputil.ErrPersistEOF": {0, DeprecatedUseNoLonger},
"net/http/httputil.ErrClosed": {0, DeprecatedUseNoLonger},
"net/http/httputil.ErrPipeline": {0, DeprecatedUseNoLonger},
"net/http/httputil.ServerConn": {0, 0},
"net/http/httputil.NewServerConn": {0, 0},
"net/http/httputil.ClientConn": {0, 0},
"net/http/httputil.NewClientConn": {0, 0},
"net/http/httputil.NewProxyClientConn": {0, 0},
"(net/http.Request).Cancel": {7, 7},
"(text/template/parse.PipeNode).Line": {1, DeprecatedUseNoLonger},
"(text/template/parse.ActionNode).Line": {1, DeprecatedUseNoLonger},
"(text/template/parse.BranchNode).Line": {1, DeprecatedUseNoLonger},
"(text/template/parse.TemplateNode).Line": {1, DeprecatedUseNoLonger},
"database/sql/driver.ColumnConverter": {9, 9},
"database/sql/driver.Execer": {8, 8},
"database/sql/driver.Queryer": {8, 8},
"(database/sql/driver.Conn).Begin": {8, 8},
"(database/sql/driver.Stmt).Exec": {8, 8},
"(database/sql/driver.Stmt).Query": {8, 8},
"syscall.StringByteSlice": {1, 1},
"syscall.StringBytePtr": {1, 1},
"syscall.StringSlicePtr": {1, 1},
"syscall.StringToUTF16": {1, 1},
"syscall.StringToUTF16Ptr": {1, 1},
"(*regexp.Regexp).Copy": {12, DeprecatedUseNoLonger},
"(archive/tar.Header).Xattrs": {10, 10},
"archive/tar.TypeRegA": {11, 1},
"go/types.NewInterface": {11, 11},
"(*go/types.Interface).Embedded": {11, 11},
"go/importer.For": {12, 12},
"encoding/json.InvalidUTF8Error": {2, DeprecatedUseNoLonger},
"encoding/json.UnmarshalFieldError": {2, DeprecatedUseNoLonger},
"encoding/csv.ErrTrailingComma": {2, DeprecatedUseNoLonger},
"(encoding/csv.Reader).TrailingComma": {2, DeprecatedUseNoLonger},
"(net.Dialer).DualStack": {12, 12},
"net/http.ErrUnexpectedTrailer": {12, DeprecatedUseNoLonger},
"net/http.CloseNotifier": {11, 7},
// This is hairy. The notice says "Not all errors in the http package related to protocol errors are of type ProtocolError", but doesn't that imply that some errors do?
"net/http.ProtocolError": {8, DeprecatedUseNoLonger},
"(crypto/x509.CertificateRequest).Attributes": {5, 3},
// These functions have no direct alternative, but they are insecure and should no longer be used.
"crypto/x509.IsEncryptedPEMBlock": {16, DeprecatedNeverUse},
"crypto/x509.DecryptPEMBlock": {16, DeprecatedNeverUse},
"crypto/x509.EncryptPEMBlock": {16, DeprecatedNeverUse},
"crypto/dsa": {16, DeprecatedNeverUse},
// This function has no alternative, but also no purpose.
"(*crypto/rc4.Cipher).Reset": {12, DeprecatedNeverUse},
"(net/http/httptest.ResponseRecorder).HeaderMap": {11, 7},
"image.ZP": {13, 0},
"image.ZR": {13, 0},
"(*debug/gosym.LineTable).LineToPC": {2, 2},
"(*debug/gosym.LineTable).PCToLine": {2, 2},
"crypto/tls.VersionSSL30": {13, DeprecatedNeverUse},
"(crypto/tls.Config).NameToCertificate": {14, DeprecatedUseNoLonger},
"(*crypto/tls.Config).BuildNameToCertificate": {14, DeprecatedUseNoLonger},
"(crypto/tls.Config).SessionTicketKey": {16, 5},
// No alternative, no use
"(crypto/tls.ConnectionState).NegotiatedProtocolIsMutual": {16, DeprecatedNeverUse},
// No alternative, but insecure
"(crypto/tls.ConnectionState).TLSUnique": {16, DeprecatedNeverUse},
"image/jpeg.Reader": {4, DeprecatedNeverUse},
// All of these have been deprecated in favour of external libraries
"syscall.AttachLsf": {7, 0},
"syscall.DetachLsf": {7, 0},
"syscall.LsfSocket": {7, 0},
"syscall.SetLsfPromisc": {7, 0},
"syscall.LsfJump": {7, 0},
"syscall.LsfStmt": {7, 0},
"syscall.BpfStmt": {7, 0},
"syscall.BpfJump": {7, 0},
"syscall.BpfBuflen": {7, 0},
"syscall.SetBpfBuflen": {7, 0},
"syscall.BpfDatalink": {7, 0},
"syscall.SetBpfDatalink": {7, 0},
"syscall.SetBpfPromisc": {7, 0},
"syscall.FlushBpf": {7, 0},
"syscall.BpfInterface": {7, 0},
"syscall.SetBpfInterface": {7, 0},
"syscall.BpfTimeout": {7, 0},
"syscall.SetBpfTimeout": {7, 0},
"syscall.BpfStats": {7, 0},
"syscall.SetBpfImmediate": {7, 0},
"syscall.SetBpf": {7, 0},
"syscall.CheckBpfVersion": {7, 0},
"syscall.BpfHeadercmpl": {7, 0},
"syscall.SetBpfHeadercmpl": {7, 0},
"syscall.RouteRIB": {8, 0},
"syscall.RoutingMessage": {8, 0},
"syscall.RouteMessage": {8, 0},
"syscall.InterfaceMessage": {8, 0},
"syscall.InterfaceAddrMessage": {8, 0},
"syscall.ParseRoutingMessage": {8, 0},
"syscall.ParseRoutingSockaddr": {8, 0},
"syscall.InterfaceAnnounceMessage": {7, 0},
"syscall.InterfaceMulticastAddrMessage": {7, 0},
"syscall.FormatMessage": {5, 0},
"syscall.PostQueuedCompletionStatus": {17, 0},
"syscall.GetQueuedCompletionStatus": {17, 0},
"syscall.CreateIoCompletionPort": {17, 0},
// Not marked as deprecated with a recognizable header, but deprecated nonetheless.
"io/ioutil": {16, 16},
}
// Last imported from Go at 32b73ae18026e8a9dc4c5aa49999b1ea445bc68c with the following numbers of deprecations:
//
// chulak go@master ./src $ rg -c "Deprecated: "
// vendor/golang.org/x/crypto/curve25519/curve25519.go:1
// vendor/golang.org/x/text/transform/transform.go:1
// cmd/compile/internal/types/sym.go:2
// syscall/route_netbsd.go:1
// syscall/route_bsd.go:7
// syscall/lsf_linux.go:6
// syscall/exec_unix.go:1
// syscall/route_darwin.go:1
// syscall/route_freebsd.go:2
// syscall/route_dragonfly.go:2
// syscall/bpf_darwin.go:18
// syscall/route_openbsd.go:1
// syscall/syscall_windows.go:6
// syscall/syscall.go:3
// syscall/bpf_bsd.go:18
// cmd/compile/internal/types2/type.go:2
// syscall/exec_plan9.go:1
// cmd/internal/obj/textflag.go:1
// cmd/internal/obj/link.go:5
// cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_arm64.go:1
// cmd/vendor/golang.org/x/mod/semver/semver.go:1
// cmd/vendor/golang.org/x/sys/windows/syscall_windows.go:2
// cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_amd64.go:1
// cmd/vendor/golang.org/x/mod/modfile/rule.go:2
// cmd/vendor/golang.org/x/sys/windows/security_windows.go:1
// cmd/go/internal/modcmd/edit.go:1
// cmd/go/testdata/mod/example.com_deprecated_a_v1.9.0.txt:2
// cmd/go/testdata/mod/example.com_undeprecated_v1.0.0.txt:2
// cmd/go/testdata/mod/example.com_deprecated_b_v1.9.0.txt:2
// encoding/csv/reader.go:2
// encoding/json/decode.go:1
// encoding/json/encode.go:1
// cmd/go/testdata/script/mod_list_deprecated.txt:2
// cmd/go/testdata/script/mod_deprecate_message.txt:4
// cmd/go/testdata/script/mod_list_deprecated_replace.txt:1
// runtime/cpuprof.go:1
// cmd/go/testdata/script/mod_edit.txt:1
// crypto/tls/common.go:6
// crypto/rc4/rc4.go:1
// crypto/dsa/dsa.go:1
// path/filepath/path_unix.go:1
// path/filepath/path_windows.go:1
// path/filepath/path_plan9.go:1
// regexp/regexp.go:1
// crypto/x509/pem_decrypt.go:3
// crypto/x509/x509.go:1
// archive/zip/struct.go:6
// archive/tar/common.go:2
// debug/gosym/pclntab.go:2
// compress/flate/inflate.go:2
// image/geom.go:2
// image/jpeg/reader.go:1
// os/file.go:1
// net/dial.go:2
// net/http/server.go:2
// net/http/socks_bundle.go:1
// net/http/httputil/persist.go:8
// net/http/request.go:6
// net/http/transport.go:3
// net/http/httptest/recorder.go:1
// go/doc/doc.go:1
// go/types/errorcodes.go:1
// go/types/type.go:2
// database/sql/driver/driver.go:6
// text/template/parse/node.go:5
// go/importer/importer.go:2
go-tools-2021.1.2/lint/ 0000775 0000000 0000000 00000000000 14143223131 0014442 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/lint/testutil/ 0000775 0000000 0000000 00000000000 14143223131 0016317 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/lint/testutil/util.go 0000664 0000000 0000000 00000001353 14143223131 0017625 0 ustar 00root root 0000000 0000000 package testutil
import (
"testing"
"honnef.co/go/tools/analysis/lint"
"golang.org/x/tools/go/analysis/analysistest"
)
type Test struct {
Dir string
Version string
}
func Run(t *testing.T, analyzers []*lint.Analyzer, tests map[string][]Test) {
for _, a := range analyzers {
a := a
t.Run(a.Analyzer.Name, func(t *testing.T) {
t.Parallel()
tt, ok := tests[a.Analyzer.Name]
if !ok {
t.Fatalf("no tests for analyzer %s", a.Analyzer.Name)
}
for _, test := range tt {
if test.Version != "" {
if err := a.Analyzer.Flags.Lookup("go").Value.Set(test.Version); err != nil {
t.Fatal(err)
}
}
analysistest.RunWithSuggestedFixes(t, analysistest.TestData(), a.Analyzer, test.Dir)
}
})
}
}
go-tools-2021.1.2/lintcmd/ 0000775 0000000 0000000 00000000000 14143223131 0015126 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/lintcmd/cmd.go 0000664 0000000 0000000 00000030041 14143223131 0016216 0 ustar 00root root 0000000 0000000 // Package lintcmd implements the frontend of an analysis runner.
// It serves as the entry-point for the staticcheck command, and can also be used to implement custom linters that behave like staticcheck.
package lintcmd
import (
"flag"
"fmt"
"log"
"os"
"reflect"
"runtime"
"runtime/pprof"
"runtime/trace"
"sort"
"strings"
"sync"
"time"
"honnef.co/go/tools/analysis/lint"
"honnef.co/go/tools/config"
"honnef.co/go/tools/go/loader"
"honnef.co/go/tools/lintcmd/version"
"golang.org/x/tools/go/analysis"
"golang.org/x/tools/go/buildutil"
)
// Command represents a linter command line tool.
type Command struct {
name string
flags *flag.FlagSet
analyzers map[string]*lint.Analyzer
version string
machineVersion string
}
// NewCommand returns a new Command.
func NewCommand(name string) *Command {
return &Command{
name: name,
flags: flagSet(name),
analyzers: map[string]*lint.Analyzer{},
version: "devel",
machineVersion: "devel",
}
}
// SetVersion sets the command's version.
// It is divided into a human part and a machine part.
// For example, Staticcheck 2020.2.1 had the human version "2020.2.1" and the machine version "v0.1.1".
// If you only use Semver, you can set both parts to the same value.
//
// Calling this method is optional. Both versions default to "devel", and we'll attempt to deduce more version information from the Go module.
func (cmd *Command) SetVersion(human, machine string) {
cmd.version = human
cmd.machineVersion = machine
}
// FlagSet returns the command's flag set.
// This can be used to add additional command line arguments.
func (cmd *Command) FlagSet() *flag.FlagSet {
return cmd.flags
}
// AddAnalyzers adds analyzers to the command.
// These are lint.Analyzer analyzers, which wrap analysis.Analyzer analyzers, bundling them with structured documentation.
//
// To add analysis.Analyzer analyzers without providing structured documentation, use AddBareAnalyzers.
func (cmd *Command) AddAnalyzers(as ...*lint.Analyzer) {
for _, a := range as {
cmd.analyzers[a.Analyzer.Name] = a
}
}
// AddBareAnalyzers adds bare analyzers to the command.
func (cmd *Command) AddBareAnalyzers(as ...*analysis.Analyzer) {
for _, a := range as {
var title, text string
if idx := strings.Index(a.Doc, "\n\n"); idx > -1 {
title = a.Doc[:idx]
text = a.Doc[idx+2:]
}
doc := &lint.Documentation{
Title: title,
Text: text,
Severity: lint.SeverityWarning,
}
cmd.analyzers[a.Name] = &lint.Analyzer{
Doc: doc,
Analyzer: a,
}
}
}
func flagSet(name string) *flag.FlagSet {
flags := flag.NewFlagSet("", flag.ExitOnError)
flags.Usage = usage(name, flags)
flags.String("tags", "", "List of `build tags`")
flags.Bool("tests", true, "Include tests")
flags.Bool("version", false, "Print version and exit")
flags.Bool("show-ignored", false, "Don't filter ignored problems")
flags.String("f", "text", "Output `format` (valid choices are 'stylish', 'text' and 'json')")
flags.String("explain", "", "Print description of `check`")
flags.Bool("list-checks", false, "List all available checks")
flags.String("debug.cpuprofile", "", "Write CPU profile to `file`")
flags.String("debug.memprofile", "", "Write memory profile to `file`")
flags.Bool("debug.version", false, "Print detailed version information about this program")
flags.Bool("debug.no-compile-errors", false, "Don't print compile errors")
flags.String("debug.measure-analyzers", "", "Write analysis measurements to `file`. `file` will be opened for appending if it already exists.")
flags.String("debug.trace", "", "Write trace to `file`")
checks := list{"inherit"}
fail := list{"all"}
version := versionFlag("module")
flags.Var(&checks, "checks", "Comma-separated list of `checks` to enable.")
flags.Var(&fail, "fail", "Comma-separated list of `checks` that can cause a non-zero exit status.")
flags.Var(&version, "go", "Target Go `version` in the format '1.x', or the literal 'module' to use the module's Go version")
return flags
}
type list []string
func (list *list) String() string {
return `"` + strings.Join(*list, ",") + `"`
}
func (list *list) Set(s string) error {
if s == "" {
*list = nil
return nil
}
*list = strings.Split(s, ",")
return nil
}
type versionFlag string
func (v *versionFlag) String() string {
return fmt.Sprintf("%q", string(*v))
}
func (v *versionFlag) Set(s string) error {
if s == "module" {
*v = "module"
} else {
var vf lint.VersionFlag
if err := vf.Set(s); err != nil {
return err
}
*v = versionFlag(s)
}
return nil
}
// ParseFlags parses command line flags.
// It must be called before calling Run.
// After calling ParseFlags, the values of flags can be accessed.
//
// Example:
//
// cmd.ParseFlags(os.Args[1:])
func (cmd *Command) ParseFlags(args []string) {
cmd.flags.Parse(args)
}
// Run runs all registered analyzers and reports their findings.
// It always calls os.Exit and does not return.
func (cmd *Command) Run() {
fs := cmd.flags
tags := fs.Lookup("tags").Value.(flag.Getter).Get().(string)
tests := fs.Lookup("tests").Value.(flag.Getter).Get().(bool)
goVersion := string(*fs.Lookup("go").Value.(*versionFlag))
theFormatter := fs.Lookup("f").Value.(flag.Getter).Get().(string)
printVersion := fs.Lookup("version").Value.(flag.Getter).Get().(bool)
showIgnored := fs.Lookup("show-ignored").Value.(flag.Getter).Get().(bool)
explain := fs.Lookup("explain").Value.(flag.Getter).Get().(string)
listChecks := fs.Lookup("list-checks").Value.(flag.Getter).Get().(bool)
cpuProfile := fs.Lookup("debug.cpuprofile").Value.(flag.Getter).Get().(string)
memProfile := fs.Lookup("debug.memprofile").Value.(flag.Getter).Get().(string)
debugVersion := fs.Lookup("debug.version").Value.(flag.Getter).Get().(bool)
debugNoCompile := fs.Lookup("debug.no-compile-errors").Value.(flag.Getter).Get().(bool)
traceOut := fs.Lookup("debug.trace").Value.(flag.Getter).Get().(string)
var measureAnalyzers func(analysis *analysis.Analyzer, pkg *loader.PackageSpec, d time.Duration)
if path := fs.Lookup("debug.measure-analyzers").Value.(flag.Getter).Get().(string); path != "" {
f, err := os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0600)
if err != nil {
log.Fatal(err)
}
mu := &sync.Mutex{}
measureAnalyzers = func(analysis *analysis.Analyzer, pkg *loader.PackageSpec, d time.Duration) {
mu.Lock()
defer mu.Unlock()
// FIXME(dh): print pkg.ID
if _, err := fmt.Fprintf(f, "%s\t%s\t%d\n", analysis.Name, pkg, d.Nanoseconds()); err != nil {
log.Println("error writing analysis measurements:", err)
}
}
}
cfg := config.Config{}
cfg.Checks = *fs.Lookup("checks").Value.(*list)
exit := func(code int) {
if cpuProfile != "" {
pprof.StopCPUProfile()
}
if memProfile != "" {
f, err := os.Create(memProfile)
if err != nil {
panic(err)
}
runtime.GC()
pprof.WriteHeapProfile(f)
}
if traceOut != "" {
trace.Stop()
}
os.Exit(code)
}
if cpuProfile != "" {
f, err := os.Create(cpuProfile)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
}
if traceOut != "" {
f, err := os.Create(traceOut)
if err != nil {
log.Fatal(err)
}
trace.Start(f)
}
if debugVersion {
version.Verbose(cmd.version, cmd.machineVersion)
exit(0)
}
cs := make([]*lint.Analyzer, 0, len(cmd.analyzers))
for _, a := range cmd.analyzers {
cs = append(cs, a)
}
if listChecks {
sort.Slice(cs, func(i, j int) bool {
return cs[i].Analyzer.Name < cs[j].Analyzer.Name
})
for _, c := range cs {
var title string
if c.Doc != nil {
title = c.Doc.Title
}
fmt.Printf("%s %s\n", c.Analyzer.Name, title)
}
exit(0)
}
if printVersion {
version.Print(cmd.version, cmd.machineVersion)
exit(0)
}
// Validate that the tags argument is well-formed. go/packages
// doesn't detect malformed build flags and returns unhelpful
// errors.
tf := buildutil.TagsFlag{}
if err := tf.Set(tags); err != nil {
fmt.Fprintln(os.Stderr, fmt.Errorf("invalid value %q for flag -tags: %s", tags, err))
exit(1)
}
if explain != "" {
check, ok := cmd.analyzers[explain]
if !ok {
fmt.Fprintln(os.Stderr, "Couldn't find check", explain)
exit(1)
}
if check.Analyzer.Doc == "" {
fmt.Fprintln(os.Stderr, explain, "has no documentation")
exit(1)
}
fmt.Println(check.Doc)
fmt.Println("Online documentation\n https://staticcheck.io/docs/checks#" + check.Analyzer.Name)
exit(0)
}
var f formatter
switch theFormatter {
case "text":
f = textFormatter{W: os.Stdout}
case "stylish":
f = &stylishFormatter{W: os.Stdout}
case "json":
f = jsonFormatter{W: os.Stdout}
case "sarif":
f = &sarifFormatter{}
case "null":
f = nullFormatter{}
default:
fmt.Fprintf(os.Stderr, "unsupported output format %q\n", theFormatter)
exit(2)
}
ps, warnings, err := doLint(cs, fs.Args(), &options{
Tags: tags,
LintTests: tests,
GoVersion: goVersion,
Config: cfg,
PrintAnalyzerMeasurement: measureAnalyzers,
})
if err != nil {
fmt.Fprintln(os.Stderr, err)
exit(1)
}
for _, w := range warnings {
fmt.Fprintln(os.Stderr, "warning:", w)
}
var (
numErrors int
numWarnings int
numIgnored int
)
fail := *fs.Lookup("fail").Value.(*list)
analyzerNames := make([]string, len(cs))
for i, a := range cs {
analyzerNames[i] = a.Analyzer.Name
}
shouldExit := filterAnalyzerNames(analyzerNames, fail)
shouldExit["staticcheck"] = true
shouldExit["compile"] = true
if f, ok := f.(complexFormatter); ok {
f.Start(cs)
}
for _, p := range ps {
if p.Category == "compile" && debugNoCompile {
continue
}
if p.Severity == severityIgnored && !showIgnored {
numIgnored++
continue
}
if shouldExit[p.Category] {
numErrors++
} else {
p.Severity = severityWarning
numWarnings++
}
f.Format(p)
}
if f, ok := f.(statter); ok {
f.Stats(len(ps), numErrors, numWarnings, numIgnored)
}
if f, ok := f.(complexFormatter); ok {
f.End()
}
if numErrors > 0 {
exit(1)
}
exit(0)
}
func usage(name string, fs *flag.FlagSet) func() {
return func() {
fmt.Fprintf(os.Stderr, "Usage: %s [flags] [packages]\n", name)
fmt.Fprintln(os.Stderr)
fmt.Fprintln(os.Stderr, "Flags:")
printDefaults(fs)
fmt.Fprintln(os.Stderr)
fmt.Fprintln(os.Stderr, "For help about specifying packages, see 'go help packages'")
}
}
// isZeroValue determines whether the string represents the zero
// value for a flag.
//
// this function has been copied from the Go standard library's 'flag' package.
func isZeroValue(f *flag.Flag, value string) bool {
// Build a zero value of the flag's Value type, and see if the
// result of calling its String method equals the value passed in.
// This works unless the Value type is itself an interface type.
typ := reflect.TypeOf(f.Value)
var z reflect.Value
if typ.Kind() == reflect.Ptr {
z = reflect.New(typ.Elem())
} else {
z = reflect.Zero(typ)
}
return value == z.Interface().(flag.Value).String()
}
// this function has been copied from the Go standard library's 'flag' package and modified to skip debug flags.
func printDefaults(fs *flag.FlagSet) {
fs.VisitAll(func(f *flag.Flag) {
// Don't print debug flags
if strings.HasPrefix(f.Name, "debug.") {
return
}
var b strings.Builder
fmt.Fprintf(&b, " -%s", f.Name) // Two spaces before -; see next two comments.
name, usage := flag.UnquoteUsage(f)
if len(name) > 0 {
b.WriteString(" ")
b.WriteString(name)
}
// Boolean flags of one ASCII letter are so common we
// treat them specially, putting their usage on the same line.
if b.Len() <= 4 { // space, space, '-', 'x'.
b.WriteString("\t")
} else {
// Four spaces before the tab triggers good alignment
// for both 4- and 8-space tab stops.
b.WriteString("\n \t")
}
b.WriteString(strings.ReplaceAll(usage, "\n", "\n \t"))
if !isZeroValue(f, f.DefValue) {
if T := reflect.TypeOf(f.Value); T.Name() == "*stringValue" && T.PkgPath() == "flag" {
// put quotes on the value
fmt.Fprintf(&b, " (default %q)", f.DefValue)
} else {
fmt.Fprintf(&b, " (default %v)", f.DefValue)
}
}
fmt.Fprint(fs.Output(), b.String(), "\n")
})
}
go-tools-2021.1.2/lintcmd/cmd_test.go 0000664 0000000 0000000 00000001622 14143223131 0017260 0 ustar 00root root 0000000 0000000 package lintcmd
import (
"go/token"
"testing"
)
func TestParsePos(t *testing.T) {
var tests = []struct {
in string
out token.Position
}{
{
"/tmp/gopackages280076669/go-build/net/cgo_linux.cgo1.go:1",
token.Position{
Filename: "/tmp/gopackages280076669/go-build/net/cgo_linux.cgo1.go",
Line: 1,
Column: 0,
},
},
{
"/tmp/gopackages280076669/go-build/net/cgo_linux.cgo1.go:1:",
token.Position{
Filename: "/tmp/gopackages280076669/go-build/net/cgo_linux.cgo1.go",
Line: 1,
Column: 0,
},
},
{
"/tmp/gopackages280076669/go-build/net/cgo_linux.cgo1.go:23:43",
token.Position{
Filename: "/tmp/gopackages280076669/go-build/net/cgo_linux.cgo1.go",
Line: 23,
Column: 43,
},
},
}
for _, tt := range tests {
res, _, _ := parsePos(tt.in)
if res != tt.out {
t.Errorf("failed to parse %q correctly", tt.in)
}
}
}
go-tools-2021.1.2/lintcmd/directives.go 0000664 0000000 0000000 00000002121 14143223131 0017612 0 ustar 00root root 0000000 0000000 package lintcmd
import (
"strings"
"honnef.co/go/tools/lintcmd/runner"
)
func parseDirectives(dirs []runner.SerializedDirective) ([]ignore, []problem) {
var ignores []ignore
var problems []problem
for _, dir := range dirs {
cmd := dir.Command
args := dir.Arguments
switch cmd {
case "ignore", "file-ignore":
if len(args) < 2 {
p := problem{
Diagnostic: runner.Diagnostic{
Position: dir.NodePosition,
Message: "malformed linter directive; missing the required reason field?",
Category: "compile",
},
Severity: severityError,
}
problems = append(problems, p)
continue
}
default:
// unknown directive, ignore
continue
}
checks := strings.Split(args[0], ",")
pos := dir.NodePosition
var ig ignore
switch cmd {
case "ignore":
ig = &lineIgnore{
File: pos.Filename,
Line: pos.Line,
Checks: checks,
Pos: dir.DirectivePosition,
}
case "file-ignore":
ig = &fileIgnore{
File: pos.Filename,
Checks: checks,
}
}
ignores = append(ignores, ig)
}
return ignores, problems
}
go-tools-2021.1.2/lintcmd/format.go 0000664 0000000 0000000 00000026104 14143223131 0016750 0 ustar 00root root 0000000 0000000 package lintcmd
import (
"encoding/json"
"fmt"
"go/token"
"io"
"os"
"path/filepath"
"text/tabwriter"
"honnef.co/go/tools/analysis/lint"
"honnef.co/go/tools/sarif"
)
func shortPath(path string) string {
cwd, err := os.Getwd()
if err != nil {
return path
}
if rel, err := filepath.Rel(cwd, path); err == nil && len(rel) < len(path) {
return rel
}
return path
}
func relativePositionString(pos token.Position) string {
s := shortPath(pos.Filename)
if pos.IsValid() {
if s != "" {
s += ":"
}
s += fmt.Sprintf("%d:%d", pos.Line, pos.Column)
}
if s == "" {
s = "-"
}
return s
}
type statter interface {
Stats(total, errors, warnings, ignored int)
}
type complexFormatter interface {
Start(checks []*lint.Analyzer)
End()
}
type formatter interface {
Format(p problem)
}
type textFormatter struct {
W io.Writer
}
func (o textFormatter) Format(p problem) {
fmt.Fprintf(o.W, "%s: %s\n", relativePositionString(p.Position), p.String())
for _, r := range p.Related {
fmt.Fprintf(o.W, "\t%s: %s\n", relativePositionString(r.Position), r.Message)
}
}
type nullFormatter struct{}
func (nullFormatter) Format(problem) {}
type jsonFormatter struct {
W io.Writer
}
func (o jsonFormatter) Format(p problem) {
type location struct {
File string `json:"file"`
Line int `json:"line"`
Column int `json:"column"`
}
type related struct {
Location location `json:"location"`
End location `json:"end"`
Message string `json:"message"`
}
jp := struct {
Code string `json:"code"`
Severity string `json:"severity,omitempty"`
Location location `json:"location"`
End location `json:"end"`
Message string `json:"message"`
Related []related `json:"related,omitempty"`
}{
Code: p.Category,
Severity: p.Severity.String(),
Location: location{
File: p.Position.Filename,
Line: p.Position.Line,
Column: p.Position.Column,
},
End: location{
File: p.End.Filename,
Line: p.End.Line,
Column: p.End.Column,
},
Message: p.Message,
}
for _, r := range p.Related {
jp.Related = append(jp.Related, related{
Location: location{
File: r.Position.Filename,
Line: r.Position.Line,
Column: r.Position.Column,
},
End: location{
File: r.End.Filename,
Line: r.End.Line,
Column: r.End.Column,
},
Message: r.Message,
})
}
_ = json.NewEncoder(o.W).Encode(jp)
}
type stylishFormatter struct {
W io.Writer
prevFile string
tw *tabwriter.Writer
}
func (o *stylishFormatter) Format(p problem) {
pos := p.Position
if pos.Filename == "" {
pos.Filename = "-"
}
if pos.Filename != o.prevFile {
if o.prevFile != "" {
o.tw.Flush()
fmt.Fprintln(o.W)
}
fmt.Fprintln(o.W, pos.Filename)
o.prevFile = pos.Filename
o.tw = tabwriter.NewWriter(o.W, 0, 4, 2, ' ', 0)
}
fmt.Fprintf(o.tw, " (%d, %d)\t%s\t%s\n", pos.Line, pos.Column, p.Category, p.Message)
for _, r := range p.Related {
fmt.Fprintf(o.tw, " (%d, %d)\t\t %s\n", r.Position.Line, r.Position.Column, r.Message)
}
}
func (o *stylishFormatter) Stats(total, errors, warnings, ignored int) {
if o.tw != nil {
o.tw.Flush()
fmt.Fprintln(o.W)
}
fmt.Fprintf(o.W, " β %d problems (%d errors, %d warnings, %d ignored)\n",
total, errors, warnings, ignored)
}
type sarifFormatter struct {
checks []*lint.Analyzer
run sarif.Run
}
func (o *sarifFormatter) Start(checks []*lint.Analyzer) {
// XXX URI-escape all locations
cwd, _ := os.Getwd()
o.checks = checks
o.run = sarif.Run{
Tool: sarif.Tool{
Driver: sarif.ToolComponent{
Name: "Staticcheck",
// XXX version.Version is useless when it's "devel"
// Version: version.Version, // XXX pass this through from the command
// XXX SemanticVersion is useless when it's "devel"
// XXX SemanticVersion shouldn't have the leading "v"
// SemanticVersion: version.MachineVersion, // XXX pass this through from the command
InformationURI: "https://staticcheck.io",
},
},
Invocations: []sarif.Invocation{{
CommandLine: "XXX",
Arguments: os.Args[1:],
WorkingDirectory: sarif.ArtifactLocation{
URI: cwd,
},
ExecutionSuccessful: true,
}},
}
for _, c := range checks {
o.run.Tool.Driver.Rules = append(o.run.Tool.Driver.Rules,
sarif.ReportingDescriptor{
// We don't set Name, as Name and ID mustn't be identical.
ID: c.Analyzer.Name,
ShortDescription: sarif.Message{
Text: c.Doc.Title,
Markdown: c.Doc.Title,
},
HelpURI: "https://staticcheck.io/docs/checks#" + c.Analyzer.Name,
// We use our markdown as the plain text version, too. We
// use very little markdown, primarily quotations,
// indented code blocks and backticks. All of these are
// fine as plain text, too.
Help: sarif.Message{
// OPT(dh): don't compute the string multiple times
Text: c.Doc.String(),
Markdown: c.Doc.String(),
},
})
}
}
func (o *sarifFormatter) sarifLevel(p problem) string {
// OPT(dh): this is O(n*m) for n analyzers and m problems
for _, c := range o.checks {
if c.Analyzer.Name == p.Category {
switch c.Doc.Severity {
case lint.SeverityNone:
// no configured severity, default to warning
return "warning"
case lint.SeverityError:
return "error"
case lint.SeverityDeprecated:
return "warning"
case lint.SeverityWarning:
return "warning"
case lint.SeverityInfo:
return "note"
case lint.SeverityHint:
return "note"
default:
// unreachable
return "none"
}
}
}
// unreachable
return "none"
}
// XXX don't add "Available since" (and other metadata) to rule descriptions.
// XXX set properties.tags β we can use different tags for the
// staticcheck, simple, stylecheck and unused checks, so users can
// filter their results
// XXX columnKind
func (o *sarifFormatter) Format(p problem) {
// Notes on GitHub-specific restrictions:
//
// Result.Message needs to either have ID or Text set. Markdown
// gets ignored. Text isn't treated verbatim however: Markdown
// formatting gets stripped, except for links.
//
// GitHub does not display RelatedLocations. The only way to make
// use of them is to link to them (via their ID) in the
// Result.Message. And even then, it will only show the referred
// line of code, not the message. We can duplicate the messages in
// the Result.Message, but we can't even indent them, because
// leading whitespace gets stripped.
//
// GitHub does use the Markdown version of rule help, but it
// renders it the way it renders comments on issues β that is, it
// turns line breaks into hard line breaks, even though it
// shouldn't.
//
// GitHub doesn't make use of the tool's URI or version, nor of
// the help URIs of rules.
//
// There does not seem to be a way of using SARIF for "normal" CI,
// without results showing up as code scanning alerts. Also, a
// SARIF file containing only warnings, no errors, will not fail
// CI. GitHub does display some parts of SARIF results in PRs, but
// most of the useful parts of SARIF, such as help text of rules,
// is only accessible via the code scanning alerts, which are only
// accessible by users with write permissions.
//
// Result.Suppressions is being ignored.
//
//
// Notes on other tools
//
// VS Code Sarif viewer
//
// The Sarif viewer in VS Code displays the full message in the
// tabular view, removing newlines. That makes our multi-line
// messages (which we use as a workaround for missing related
// information) very ugly.
//
// Much like GitHub, the Sarif viewer does not make related
// information visible unless we explicitly refer to it in the
// message.
//
// Suggested fixes are not exposed in any way.
//
// It only shows the shortDescription or fullDescription of a
// rule, not its help. We can't put the help in fullDescription,
// because the fullDescription isn't meant to be that long. For
// example, GitHub displays it in a single line, under the
// shortDescription.
//
// VS Code can filter based on Result.Suppressions, but it doesn't
// display our suppression message. Also, by default, suppressed
// results get shown, and the column indicating that a result is
// suppressed is hidden, which makes for a confusing experience.
//
// When a rule has only an ID, no name, VS Code displays a
// prominent dash in place of the name. When the name and ID are
// identical, it prints both. However, we can't make them
// identical, as SARIF requires that either the ID and name are
// different, or that the name is omitted.
r := sarif.Result{
RuleID: p.Category,
Kind: sarif.Fail,
Level: o.sarifLevel(p),
Message: sarif.Message{Text: p.Message},
}
r.Locations = []sarif.Location{{
PhysicalLocation: sarif.PhysicalLocation{
ArtifactLocation: sarif.ArtifactLocation{
URI: "file://" + p.Position.Filename,
Index: -1,
},
Region: sarif.Region{
StartLine: p.Position.Line,
StartColumn: p.Position.Column, // XXX sarif is 1-based; are we?
EndLine: p.End.Line,
EndColumn: p.End.Column,
},
},
}}
for _, fix := range p.SuggestedFixes {
sfix := sarif.Fix{
Description: sarif.Message{Text: fix.Message},
}
// file name -> replacements
changes := map[string][]sarif.Replacement{}
for _, edit := range fix.TextEdits {
changes[edit.Position.Filename] = append(changes[edit.Position.Filename], sarif.Replacement{
DeletedRegion: sarif.Region{
StartLine: edit.Position.Line,
StartColumn: edit.Position.Column,
EndLine: edit.End.Line,
EndColumn: edit.End.Column,
},
InsertedContent: sarif.ArtifactContent{
Text: string(edit.NewText),
},
})
}
for path, replacements := range changes {
sfix.ArtifactChanges = append(sfix.ArtifactChanges, sarif.ArtifactChange{
ArtifactLocation: sarif.ArtifactLocation{
URI: "file://" + path,
},
Replacements: replacements,
})
}
r.Fixes = append(r.Fixes, sfix)
}
for i, related := range p.Related {
r.Message.Text += fmt.Sprintf("\n\t[%s](%d)", related.Message, i+1)
r.RelatedLocations = append(r.RelatedLocations,
sarif.Location{
ID: i + 1,
Message: &sarif.Message{
Text: related.Message,
},
PhysicalLocation: sarif.PhysicalLocation{
ArtifactLocation: sarif.ArtifactLocation{
URI: "file://" + related.Position.Filename,
Index: -1,
},
Region: sarif.Region{
StartLine: related.Position.Line,
StartColumn: related.Position.Column,
EndLine: related.End.Line,
EndColumn: related.End.Column,
},
},
})
}
if p.Severity == severityIgnored {
r.Suppressions = []sarif.Suppression{{
Kind: "inSource",
Justification: "to be filled in",
}}
} else {
// We want an empty slice, not nil. SARIF differentiates
// between the two. An empty slice means that the problem
// wasn't suppressed, while nil means that we don't have the
// information available.
r.Suppressions = []sarif.Suppression{}
}
o.run.Results = append(o.run.Results, r)
}
func (o *sarifFormatter) End() {
// XXX populate artifacts
json.NewEncoder(os.Stdout).Encode(sarif.Log{
Version: sarif.Version,
Schema: sarif.Schema,
Runs: []sarif.Run{o.run},
})
}
go-tools-2021.1.2/lintcmd/lint.go 0000664 0000000 0000000 00000031402 14143223131 0016423 0 ustar 00root root 0000000 0000000 package lintcmd
import (
"crypto/sha256"
"fmt"
"go/build"
"go/token"
"io"
"os"
"os/signal"
"path/filepath"
"regexp"
"sort"
"strconv"
"strings"
"time"
"unicode"
"honnef.co/go/tools/analysis/lint"
"honnef.co/go/tools/config"
"honnef.co/go/tools/go/loader"
"honnef.co/go/tools/internal/cache"
"honnef.co/go/tools/lintcmd/runner"
"honnef.co/go/tools/unused"
"golang.org/x/tools/go/analysis"
"golang.org/x/tools/go/packages"
)
// A linter lints Go source code.
type linter struct {
Checkers []*lint.Analyzer
Config config.Config
Runner *runner.Runner
}
func computeSalt() ([]byte, error) {
p, err := os.Executable()
if err != nil {
return nil, err
}
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 newLinter(cfg config.Config) (*linter, error) {
c, err := cache.Default()
if err != nil {
return nil, err
}
salt, err := computeSalt()
if err != nil {
return nil, fmt.Errorf("could not compute salt for cache: %s", err)
}
c.SetSalt(salt)
r, err := runner.New(cfg, c)
if err != nil {
return nil, err
}
r.FallbackGoVersion = defaultGoVersion()
return &linter{
Config: cfg,
Runner: r,
}, nil
}
func (l *linter) Lint(cfg *packages.Config, patterns []string) (problems []problem, warnings []string, err error) {
cs := make([]*analysis.Analyzer, len(l.Checkers))
for i, a := range l.Checkers {
cs[i] = a.Analyzer
}
results, err := l.Runner.Run(cfg, cs, patterns)
if err != nil {
return nil, nil, err
}
if len(results) == 0 && err == nil {
// TODO(dh): emulate Go's behavior more closely once we have
// access to go list's Match field.
for _, pattern := range patterns {
fmt.Fprintf(os.Stderr, "warning: %q matched no packages\n", pattern)
}
}
analyzerNames := make([]string, len(l.Checkers))
for i, a := range l.Checkers {
analyzerNames[i] = a.Analyzer.Name
}
used := map[unusedKey]bool{}
var unuseds []unusedPair
for _, res := range results {
if len(res.Errors) > 0 && !res.Failed {
panic("package has errors but isn't marked as failed")
}
if res.Failed {
problems = append(problems, failed(res)...)
} else {
if res.Skipped {
warnings = append(warnings, fmt.Sprintf("skipped package %s because it is too large", res.Package))
continue
}
if !res.Initial {
continue
}
allowedAnalyzers := filterAnalyzerNames(analyzerNames, res.Config.Checks)
resd, err := res.Load()
if err != nil {
return nil, nil, err
}
ps := success(allowedAnalyzers, resd)
filtered, err := filterIgnored(ps, resd, allowedAnalyzers)
if err != nil {
return nil, nil, err
}
problems = append(problems, filtered...)
for _, obj := range resd.Unused.Used {
// FIXME(dh): pick the object whose filename does not include $GOROOT
key := unusedKey{
pkgPath: res.Package.PkgPath,
base: filepath.Base(obj.Position.Filename),
line: obj.Position.Line,
name: obj.Name,
}
used[key] = true
}
if allowedAnalyzers["U1000"] {
for _, obj := range resd.Unused.Unused {
key := unusedKey{
pkgPath: res.Package.PkgPath,
base: filepath.Base(obj.Position.Filename),
line: obj.Position.Line,
name: obj.Name,
}
unuseds = append(unuseds, unusedPair{key, obj})
if _, ok := used[key]; !ok {
used[key] = false
}
}
}
}
}
for _, uo := range unuseds {
if used[uo.key] {
continue
}
if uo.obj.InGenerated {
continue
}
problems = append(problems, problem{
Diagnostic: runner.Diagnostic{
Position: uo.obj.DisplayPosition,
Message: fmt.Sprintf("%s %s is unused", uo.obj.Kind, uo.obj.Name),
Category: "U1000",
},
})
}
if len(problems) == 0 {
return nil, warnings, nil
}
sort.Slice(problems, func(i, j int) bool {
pi := problems[i].Position
pj := problems[j].Position
if pi.Filename != pj.Filename {
return pi.Filename < pj.Filename
}
if pi.Line != pj.Line {
return pi.Line < pj.Line
}
if pi.Column != pj.Column {
return pi.Column < pj.Column
}
return problems[i].Message < problems[j].Message
})
var out []problem
out = append(out, problems[0])
for i, p := range problems[1:] {
// We may encounter duplicate problems because one file
// can be part of many packages.
if !problems[i].equal(p) {
out = append(out, p)
}
}
return out, warnings, nil
}
func filterIgnored(problems []problem, res runner.ResultData, allowedAnalyzers map[string]bool) ([]problem, error) {
couldHaveMatched := func(ig *lineIgnore) bool {
for _, c := range ig.Checks {
if c == "U1000" {
// We never want to flag ignores for U1000,
// because U1000 isn't local to a single
// package. For example, an identifier may
// only be used by tests, in which case an
// ignore would only fire when not analyzing
// tests. To avoid spurious "useless ignore"
// warnings, just never flag U1000.
return false
}
// Even though the runner always runs all analyzers, we
// still only flag unmatched ignores for the set of
// analyzers the user has expressed interest in. That way,
// `staticcheck -checks=SA1000` won't complain about an
// unmatched ignore for an unrelated check.
if allowedAnalyzers[c] {
return true
}
}
return false
}
ignores, moreProblems := parseDirectives(res.Directives)
for _, ig := range ignores {
for i := range problems {
p := &problems[i]
if ig.Match(*p) {
p.Severity = severityIgnored
}
}
if ig, ok := ig.(*lineIgnore); ok && !ig.Matched && couldHaveMatched(ig) {
p := problem{
Diagnostic: runner.Diagnostic{
Position: ig.Pos,
Message: "this linter directive didn't match anything; should it be removed?",
Category: "staticcheck",
},
}
moreProblems = append(moreProblems, p)
}
}
return append(problems, moreProblems...), nil
}
type ignore interface {
Match(p problem) bool
}
type lineIgnore struct {
File string
Line int
Checks []string
Matched bool
Pos token.Position
}
func (li *lineIgnore) Match(p problem) bool {
pos := p.Position
if pos.Filename != li.File || pos.Line != li.Line {
return false
}
for _, c := range li.Checks {
if m, _ := filepath.Match(c, p.Category); m {
li.Matched = true
return true
}
}
return false
}
func (li *lineIgnore) String() string {
matched := "not matched"
if li.Matched {
matched = "matched"
}
return fmt.Sprintf("%s:%d %s (%s)", li.File, li.Line, strings.Join(li.Checks, ", "), matched)
}
type fileIgnore struct {
File string
Checks []string
}
func (fi *fileIgnore) Match(p problem) bool {
if p.Position.Filename != fi.File {
return false
}
for _, c := range fi.Checks {
if m, _ := filepath.Match(c, p.Category); m {
return true
}
}
return false
}
type severity uint8
const (
severityError severity = iota
severityWarning
severityIgnored
)
func (s severity) String() string {
switch s {
case severityError:
return "error"
case severityWarning:
return "warning"
case severityIgnored:
return "ignored"
default:
return fmt.Sprintf("Severity(%d)", s)
}
}
// problem represents a problem in some source code.
type problem struct {
runner.Diagnostic
Severity severity
}
func (p problem) equal(o problem) bool {
return p.Position == o.Position &&
p.End == o.End &&
p.Message == o.Message &&
p.Category == o.Category &&
p.Severity == o.Severity
}
func (p *problem) String() string {
return fmt.Sprintf("%s (%s)", p.Message, p.Category)
}
func failed(res runner.Result) []problem {
var problems []problem
for _, e := range res.Errors {
switch e := e.(type) {
case packages.Error:
msg := e.Msg
if len(msg) != 0 && msg[0] == '\n' {
// TODO(dh): See https://github.com/golang/go/issues/32363
msg = msg[1:]
}
var posn token.Position
if e.Pos == "" {
// Under certain conditions (malformed package
// declarations, multiple packages in the same
// directory), go list emits an error on stderr
// instead of JSON. Those errors do not have
// associated position information in
// go/packages.Error, even though the output on
// stderr may contain it.
if p, n, err := parsePos(msg); err == nil {
if abs, err := filepath.Abs(p.Filename); err == nil {
p.Filename = abs
}
posn = p
msg = msg[n+2:]
}
} else {
var err error
posn, _, err = parsePos(e.Pos)
if err != nil {
panic(fmt.Sprintf("internal error: %s", e))
}
}
p := problem{
Diagnostic: runner.Diagnostic{
Position: posn,
Message: msg,
Category: "compile",
},
Severity: severityError,
}
problems = append(problems, p)
case error:
p := problem{
Diagnostic: runner.Diagnostic{
Position: token.Position{},
Message: e.Error(),
Category: "compile",
},
Severity: severityError,
}
problems = append(problems, p)
}
}
return problems
}
type unusedKey struct {
pkgPath string
base string
line int
name string
}
type unusedPair struct {
key unusedKey
obj unused.SerializedObject
}
func success(allowedChecks map[string]bool, res runner.ResultData) []problem {
diags := res.Diagnostics
var problems []problem
for _, diag := range diags {
if !allowedChecks[diag.Category] {
continue
}
problems = append(problems, problem{Diagnostic: diag})
}
return problems
}
func defaultGoVersion() string {
tags := build.Default.ReleaseTags
v := tags[len(tags)-1][2:]
return v
}
func filterAnalyzerNames(analyzers []string, checks []string) map[string]bool {
allowedChecks := map[string]bool{}
for _, check := range checks {
b := true
if len(check) > 1 && check[0] == '-' {
b = false
check = check[1:]
}
if check == "*" || check == "all" {
// Match all
for _, c := range analyzers {
allowedChecks[c] = b
}
} else if strings.HasSuffix(check, "*") {
// Glob
prefix := check[:len(check)-1]
isCat := strings.IndexFunc(prefix, func(r rune) bool { return unicode.IsNumber(r) }) == -1
for _, a := range analyzers {
idx := strings.IndexFunc(a, func(r rune) bool { return unicode.IsNumber(r) })
if isCat {
// Glob is S*, which should match S1000 but not SA1000
cat := a[:idx]
if prefix == cat {
allowedChecks[a] = b
}
} else {
// Glob is S1*
if strings.HasPrefix(a, prefix) {
allowedChecks[a] = b
}
}
}
} else {
// Literal check name
allowedChecks[check] = b
}
}
return allowedChecks
}
var posRe = regexp.MustCompile(`^(.+?):(\d+)(?::(\d+)?)?`)
func parsePos(pos string) (token.Position, int, error) {
if pos == "-" || pos == "" {
return token.Position{}, 0, nil
}
parts := posRe.FindStringSubmatch(pos)
if parts == nil {
return token.Position{}, 0, fmt.Errorf("internal error: malformed position %q", pos)
}
file := parts[1]
line, _ := strconv.Atoi(parts[2])
col, _ := strconv.Atoi(parts[3])
return token.Position{
Filename: file,
Line: line,
Column: col,
}, len(parts[0]), nil
}
type options struct {
Config config.Config
Tags string
LintTests bool
GoVersion string
PrintAnalyzerMeasurement func(analysis *analysis.Analyzer, pkg *loader.PackageSpec, d time.Duration)
}
func doLint(cs []*lint.Analyzer, paths []string, opt *options) ([]problem, []string, error) {
if opt == nil {
opt = &options{}
}
l, err := newLinter(opt.Config)
if err != nil {
return nil, nil, err
}
l.Checkers = cs
l.Runner.GoVersion = opt.GoVersion
l.Runner.Stats.PrintAnalyzerMeasurement = opt.PrintAnalyzerMeasurement
cfg := &packages.Config{}
if opt.LintTests {
cfg.Tests = true
}
if opt.Tags != "" {
cfg.BuildFlags = append(cfg.BuildFlags, "-tags", opt.Tags)
}
printStats := func() {
// Individual stats are read atomically, but overall there
// is no synchronisation. For printing rough progress
// information, this doesn't matter.
switch l.Runner.Stats.State() {
case runner.StateInitializing:
fmt.Fprintln(os.Stderr, "Status: initializing")
case runner.StateLoadPackageGraph:
fmt.Fprintln(os.Stderr, "Status: loading package graph")
case runner.StateBuildActionGraph:
fmt.Fprintln(os.Stderr, "Status: building action graph")
case runner.StateProcessing:
fmt.Fprintf(os.Stderr, "Packages: %d/%d initial, %d/%d total; Workers: %d/%d\n",
l.Runner.Stats.ProcessedInitialPackages(),
l.Runner.Stats.InitialPackages(),
l.Runner.Stats.ProcessedPackages(),
l.Runner.Stats.TotalPackages(),
l.Runner.ActiveWorkers(),
l.Runner.TotalWorkers(),
)
case runner.StateFinalizing:
fmt.Fprintln(os.Stderr, "Status: finalizing")
}
}
if len(infoSignals) > 0 {
ch := make(chan os.Signal, 1)
signal.Notify(ch, infoSignals...)
defer signal.Stop(ch)
go func() {
for range ch {
printStats()
}
}()
}
return l.Lint(cfg, paths)
}
go-tools-2021.1.2/lintcmd/lint_test.go 0000664 0000000 0000000 00000005231 14143223131 0017463 0 ustar 00root root 0000000 0000000 package lintcmd
import (
"go/token"
"log"
"os"
"path/filepath"
"runtime"
"strings"
"testing"
"honnef.co/go/tools/config"
"honnef.co/go/tools/lintcmd/runner"
"golang.org/x/tools/go/packages"
)
func testdata() string {
testdata, err := filepath.Abs("testdata")
if err != nil {
log.Fatal(err)
}
return testdata
}
func lintPackage(t *testing.T, name string) []problem {
l, err := newLinter(config.Config{})
if err != nil {
t.Fatal(err)
}
cfg := &packages.Config{
Env: append(os.Environ(), "GOPATH="+testdata(), "GO111MODULE=off"),
}
ps, _, err := l.Lint(cfg, []string{name})
if err != nil {
t.Fatal(err)
}
return ps
}
func trimPosition(pos *token.Position) {
idx := strings.Index(pos.Filename, "/testdata/src/")
if idx >= 0 {
pos.Filename = pos.Filename[idx+len("/testdata/src/"):]
}
}
func TestErrors(t *testing.T) {
t.Run("invalid package declaration", func(t *testing.T) {
ps := lintPackage(t, "broken_pkgerror")
if len(ps) != 1 {
t.Fatalf("got %d problems, want 1", len(ps))
}
if want := "expected 'package', found pckage"; ps[0].Message != want {
t.Errorf("got message %q, want %q", ps[0].Message, want)
}
if ps[0].Position.Filename == "" {
t.Errorf("didn't get useful position")
}
})
t.Run("type error", func(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("don't deal with Windows line endings or absolute file names")
}
ps := lintPackage(t, "broken_typeerror")
if len(ps) != 1 {
t.Fatalf("got %d problems, want 1", len(ps))
}
trimPosition(&ps[0].Position)
want := problem{
Diagnostic: runner.Diagnostic{
Position: token.Position{
Filename: "broken_typeerror/pkg.go",
Offset: 0,
Line: 5,
Column: 10,
},
Message: "cannot convert \"\" (untyped string constant) to int",
Category: "compile",
},
Severity: 0,
}
if !ps[0].equal(want) {
t.Errorf("got %#v, want %#v", ps[0], want)
}
})
t.Run("missing dep", func(t *testing.T) {
t.Skip("Go 1.12 behaves incorrectly for missing packages")
})
t.Run("parse error", func(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("don't deal with Windows line endings or absolute file names")
}
ps := lintPackage(t, "broken_parse")
if len(ps) != 1 {
t.Fatalf("got %d problems, want 1", len(ps))
}
trimPosition(&ps[0].Position)
want := problem{
Diagnostic: runner.Diagnostic{
Position: token.Position{
Filename: "broken_parse/pkg.go",
Offset: 0,
Line: 3,
Column: 1,
},
Message: "expected declaration, found asd",
Category: "compile",
},
Severity: 0,
}
if !ps[0].equal(want) {
t.Errorf("got %#v, want %#v", ps[0], want)
}
})
}
go-tools-2021.1.2/lintcmd/runner/ 0000775 0000000 0000000 00000000000 14143223131 0016437 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/lintcmd/runner/runner.go 0000664 0000000 0000000 00000101055 14143223131 0020301 0 ustar 00root root 0000000 0000000 // Package runner implements a go/analysis runner. It makes heavy use
// of on-disk caching to reduce overall memory usage and to speed up
// repeat runs.
//
// Public API
//
// A Runner maps a list of analyzers and package patterns to a list of
// results. Results provide access to diagnostics, directives, errors
// encountered, and information about packages. Results explicitly do
// not contain ASTs or type information. All position information is
// returned in the form of token.Position, not token.Pos. All work
// that requires access to the loaded representation of a package has
// to occur inside analyzers.
//
// Planning and execution
//
// Analyzing packages is split into two phases: planning and
// execution.
//
// During planning, a directed acyclic graph of package dependencies
// is computed. We materialize the full graph so that we can execute
// the graph from the bottom up, without keeping unnecessary data in
// memory during a DFS and with simplified parallel execution.
//
// During execution, leaf nodes (nodes with no outstanding
// dependencies) get executed in parallel, bounded by a semaphore
// sized according to the number of CPUs. Conceptually, this happens
// in a loop, processing new leaf nodes as they appear, until no more
// nodes are left. In the actual implementation, nodes know their
// dependents, and the last dependency of a node to be processed is
// responsible for scheduling its dependent.
//
// The graph is rooted at a synthetic root node. Upon execution of the
// root node, the algorithm terminates.
//
// Analyzing a package repeats the same planning + execution steps,
// but this time on a graph of analyzers for the package. Parallel
// execution of individual analyzers is bounded by the same semaphore
// as executing packages.
//
// Parallelism
//
// Actions are executed in parallel where the dependency graph allows.
// Overall parallelism is bounded by a semaphore, sized according to
// GOMAXPROCS. Each concurrently processed package takes up a
// token, as does each analyzer β but a package can always execute at
// least one analyzer, using the package's token.
//
// Depending on the overall shape of the graph, there may be GOMAXPROCS
// packages running a single analyzer each, a single package running
// GOMAXPROCS analyzers, or anything in between.
//
// Total memory consumption grows roughly linearly with the number of
// CPUs, while total execution time is inversely proportional to the
// number of CPUs. Overall, parallelism is affected by the shape of
// the dependency graph. A lot of inter-connected packages will see
// less parallelism than a lot of independent packages.
//
// Caching
//
// The runner caches facts, directives and diagnostics in a
// content-addressable cache that is designed after Go's own cache.
// Additionally, it makes use of Go's export data.
//
// This cache not only speeds up repeat runs, it also reduces peak
// memory usage. When we've analyzed a package, we cache the results
// and drop them from memory. When a dependent needs any of this
// information, or when analysis is complete and we wish to render the
// results, the data gets loaded from disk again.
//
// Data only exists in memory when it is immediately needed, not
// retained for possible future uses. This trades increased CPU usage
// for reduced memory usage. A single dependency may be loaded many
// times over, but it greatly reduces peak memory usage, as an
// arbitrary amount of time may pass between analyzing a dependency
// and its dependent, during which other packages will be processed.
package runner
// OPT(dh): we could reduce disk storage usage of cached data by
// compressing it, either directly at the cache layer, or by feeding
// compressed data to the cache. Of course doing so may negatively
// affect CPU usage, and there are lower hanging fruit, such as
// needing to cache less data in the first place.
// OPT(dh): right now, each package is analyzed completely
// independently. Each package loads all of its dependencies from
// export data and cached facts. If we have two packages A and B,
// which both depend on C, and which both get analyzed in parallel,
// then C will be loaded twice. This wastes CPU time and memory. It
// would be nice if we could reuse a single C for the analysis of both
// A and B.
//
// We can't reuse the actual types.Package or facts, because each
// package gets its own token.FileSet. Sharing a global FileSet has
// several drawbacks, including increased memory usage and running the
// risk of running out of FileSet address space.
//
// We could however avoid loading the same raw export data from disk
// twice, as well as deserializing gob data twice. One possible
// solution would be a duplicate-suppressing in-memory cache that
// caches data for a limited amount of time. When the same package
// needs to be loaded twice in close succession, we can reuse work,
// without holding unnecessary data in memory for an extended period
// of time.
//
// We would likely need to do extensive benchmarking to figure out how
// long to keep data around to find a sweet spot where we reduce CPU
// load without increasing memory usage.
//
// We can probably populate the cache after we've analyzed a package,
// on the assumption that it will have to be loaded again in the near
// future.
import (
"encoding/gob"
"fmt"
"go/token"
"go/types"
"io"
"io/ioutil"
"os"
"reflect"
"runtime"
"sort"
"strings"
"sync/atomic"
"time"
"honnef.co/go/tools/analysis/lint"
"honnef.co/go/tools/analysis/report"
"honnef.co/go/tools/config"
"honnef.co/go/tools/go/loader"
"honnef.co/go/tools/internal/cache"
tsync "honnef.co/go/tools/internal/sync"
"honnef.co/go/tools/unused"
"golang.org/x/tools/go/analysis"
"golang.org/x/tools/go/packages"
"golang.org/x/tools/go/types/objectpath"
)
const sanityCheck = false
type Diagnostic struct {
Position token.Position
End token.Position
Category string
Message string
SuggestedFixes []SuggestedFix
Related []RelatedInformation
}
// RelatedInformation provides additional context for a diagnostic.
type RelatedInformation struct {
Position token.Position
End token.Position
Message string
}
type SuggestedFix struct {
Message string
TextEdits []TextEdit
}
type TextEdit struct {
Position token.Position
End token.Position
NewText []byte
}
// A Result describes the result of analyzing a single package.
//
// It holds references to cached diagnostics and directives. They can
// be loaded on demand with Diagnostics and Directives respectively.
type Result struct {
Package *loader.PackageSpec
Config config.Config
Initial bool
Skipped bool
Failed bool
Errors []error
// Action results, paths to files
results string
}
type SerializedDirective struct {
Command string
Arguments []string
// The position of the comment
DirectivePosition token.Position
// The position of the node that the comment is attached to
NodePosition token.Position
}
func serializeDirective(dir lint.Directive, fset *token.FileSet) SerializedDirective {
return SerializedDirective{
Command: dir.Command,
Arguments: dir.Arguments,
DirectivePosition: report.DisplayPosition(fset, dir.Directive.Pos()),
NodePosition: report.DisplayPosition(fset, dir.Node.Pos()),
}
}
type ResultData struct {
Directives []SerializedDirective
Diagnostics []Diagnostic
Unused unused.SerializedResult
}
func (r Result) Load() (ResultData, error) {
if r.Failed {
panic("Load called on failed Result")
}
if r.results == "" {
// this package was only a dependency
return ResultData{}, nil
}
f, err := os.Open(r.results)
if err != nil {
return ResultData{}, fmt.Errorf("failed loading result: %w", err)
}
defer f.Close()
var out ResultData
err = gob.NewDecoder(f).Decode(&out)
return out, err
}
type action interface {
Deps() []action
Triggers() []action
DecrementPending() bool
MarkFailed()
IsFailed() bool
AddError(error)
}
type baseAction struct {
// Action description
deps []action
triggers []action
pending uint32
// Action results
// failed is set to true if the action couldn't be processed. This
// may either be due to an error specific to this action, in
// which case the errors field will be populated, or due to a
// dependency being marked as failed, in which case errors will be
// empty.
failed bool
errors []error
}
func (act *baseAction) Deps() []action { return act.deps }
func (act *baseAction) Triggers() []action { return act.triggers }
func (act *baseAction) DecrementPending() bool {
return atomic.AddUint32(&act.pending, ^uint32(0)) == 0
}
func (act *baseAction) MarkFailed() { act.failed = true }
func (act *baseAction) IsFailed() bool { return act.failed }
func (act *baseAction) AddError(err error) { act.errors = append(act.errors, err) }
// packageAction describes the act of loading a package, fully
// analyzing it, and storing the results.
type packageAction struct {
baseAction
// Action description
Package *loader.PackageSpec
factsOnly bool
hash cache.ActionID
// Action results
cfg config.Config
vetx string
results string
skipped bool
}
func (act *packageAction) String() string {
return fmt.Sprintf("packageAction(%s)", act.Package)
}
type objectFact struct {
fact analysis.Fact
path objectpath.Path
}
type objectFactKey struct {
Obj types.Object
Type reflect.Type
}
type packageFactKey struct {
Pkg *types.Package
Type reflect.Type
}
type gobFact struct {
PkgPath string
ObjPath string
Fact analysis.Fact
}
// analyzerAction describes the act of analyzing a package with a
// single analyzer.
type analyzerAction struct {
baseAction
// Action description
Analyzer *analysis.Analyzer
// Action results
// We can store actual results here without worrying about memory
// consumption because analyzer actions get garbage collected once
// a package has been fully analyzed.
Result interface{}
Diagnostics []Diagnostic
ObjectFacts map[objectFactKey]objectFact
PackageFacts map[packageFactKey]analysis.Fact
Pass *analysis.Pass
}
func (act *analyzerAction) String() string {
return fmt.Sprintf("analyzerAction(%s)", act.Analyzer)
}
// A Runner executes analyzers on packages.
type Runner struct {
Stats Stats
GoVersion string
// if GoVersion == "module", and we couldn't determine the
// module's Go version, use this as the fallback
FallbackGoVersion string
// GoVersion might be "module"; actualGoVersion contains the resolved version
actualGoVersion string
// Config that gets merged with per-package configs
cfg config.Config
cache *cache.Cache
semaphore tsync.Semaphore
}
type subrunner struct {
*Runner
analyzers []*analysis.Analyzer
factAnalyzers []*analysis.Analyzer
analyzerNames string
cache *cache.Cache
}
// New returns a new Runner.
func New(cfg config.Config, c *cache.Cache) (*Runner, error) {
return &Runner{
cfg: cfg,
cache: c,
semaphore: tsync.NewSemaphore(runtime.GOMAXPROCS(0)),
}, nil
}
func newSubrunner(r *Runner, analyzers []*analysis.Analyzer) *subrunner {
analyzerNames := make([]string, len(analyzers))
for i, a := range analyzers {
analyzerNames[i] = a.Name
}
sort.Strings(analyzerNames)
var factAnalyzers []*analysis.Analyzer
for _, a := range analyzers {
if len(a.FactTypes) > 0 {
factAnalyzers = append(factAnalyzers, a)
}
}
return &subrunner{
Runner: r,
analyzers: analyzers,
factAnalyzers: factAnalyzers,
analyzerNames: strings.Join(analyzerNames, ","),
cache: r.cache,
}
}
func newPackageActionRoot(pkg *loader.PackageSpec, cache map[*loader.PackageSpec]*packageAction) *packageAction {
a := newPackageAction(pkg, cache)
a.factsOnly = false
return a
}
func newPackageAction(pkg *loader.PackageSpec, cache map[*loader.PackageSpec]*packageAction) *packageAction {
if a, ok := cache[pkg]; ok {
return a
}
a := &packageAction{
Package: pkg,
factsOnly: true, // will be overwritten by any call to Action
}
cache[pkg] = a
if len(pkg.Errors) > 0 {
a.errors = make([]error, len(pkg.Errors))
for i, err := range pkg.Errors {
a.errors[i] = err
}
a.failed = true
// We don't need to process our imports if this package is
// already broken.
return a
}
a.deps = make([]action, 0, len(pkg.Imports))
for _, dep := range pkg.Imports {
depa := newPackageAction(dep, cache)
depa.triggers = append(depa.triggers, a)
a.deps = append(a.deps, depa)
if depa.failed {
a.failed = true
}
}
// sort dependencies because the list of dependencies is part of
// the cache key
sort.Slice(a.deps, func(i, j int) bool {
return a.deps[i].(*packageAction).Package.ID < a.deps[j].(*packageAction).Package.ID
})
a.pending = uint32(len(a.deps))
return a
}
func newAnalyzerAction(an *analysis.Analyzer, cache map[*analysis.Analyzer]*analyzerAction) *analyzerAction {
if a, ok := cache[an]; ok {
return a
}
a := &analyzerAction{
Analyzer: an,
ObjectFacts: map[objectFactKey]objectFact{},
PackageFacts: map[packageFactKey]analysis.Fact{},
}
cache[an] = a
for _, dep := range an.Requires {
depa := newAnalyzerAction(dep, cache)
depa.triggers = append(depa.triggers, a)
a.deps = append(a.deps, depa)
}
a.pending = uint32(len(a.deps))
return a
}
func getCachedFiles(cache *cache.Cache, ids []cache.ActionID, out []*string) error {
for i, id := range ids {
var err error
*out[i], _, err = cache.GetFile(id)
if err != nil {
return err
}
}
return nil
}
func (r *subrunner) do(act action) error {
a := act.(*packageAction)
defer func() {
r.Stats.finishPackage()
if !a.factsOnly {
r.Stats.finishInitialPackage()
}
}()
// compute hash of action
a.cfg = a.Package.Config.Merge(r.cfg)
h := r.cache.NewHash("staticcheck " + a.Package.PkgPath)
// Note that we do not filter the list of analyzers by the
// package's configuration. We don't allow configuration to
// accidentally break dependencies between analyzers, and it's
// easier to always run all checks and filter the output. This
// also makes cached data more reusable.
// OPT(dh): not all changes in configuration invalidate cached
// data. specifically, when a.factsOnly == true, we only care
// about checks that produce facts, and settings that affect those
// checks.
// Config used for constructing the hash; this config doesn't have
// Checks populated, because we always run all checks.
//
// This even works for users who add custom checks, because we include the binary's hash.
hashCfg := a.cfg
hashCfg.Checks = nil
// note that we don't hash staticcheck's version; it is set as the
// salt by a package main.
fmt.Fprintf(h, "cfg %#v\n", hashCfg)
fmt.Fprintf(h, "pkg %x\n", a.Package.Hash)
fmt.Fprintf(h, "analyzers %s\n", r.analyzerNames)
fmt.Fprintf(h, "go %s\n", r.actualGoVersion)
// OPT(dh): do we actually need to hash vetx? can we not assume
// that for identical inputs, staticcheck will produce identical
// vetx?
for _, dep := range a.deps {
dep := dep.(*packageAction)
vetxHash, err := cache.FileHash(dep.vetx)
if err != nil {
return fmt.Errorf("failed computing hash: %w", err)
}
fmt.Fprintf(h, "vetout %q %x\n", dep.Package.PkgPath, vetxHash)
}
a.hash = cache.ActionID(h.Sum())
// try to fetch hashed data
ids := make([]cache.ActionID, 0, 2)
ids = append(ids, cache.Subkey(a.hash, "vetx"))
if !a.factsOnly {
ids = append(ids, cache.Subkey(a.hash, "results"))
}
if err := getCachedFiles(r.cache, ids, []*string{&a.vetx, &a.results}); err != nil {
result, err := r.doUncached(a)
if err != nil {
return err
}
if a.failed {
return nil
}
a.skipped = result.skipped
// OPT(dh) instead of collecting all object facts and encoding
// them after analysis finishes, we could encode them as we
// go. however, that would require some locking.
//
// OPT(dh): We could sort gobFacts for more consistent output,
// but it doesn't matter. The hash of a package includes all
// of its files, so whether the vetx hash changes or not, a
// change to a package requires re-analyzing all dependents,
// even if the vetx data stayed the same. See also the note at
// the top of loader/hash.go.
tf, err := ioutil.TempFile("", "staticcheck")
if err != nil {
return err
}
defer tf.Close()
os.Remove(tf.Name())
enc := gob.NewEncoder(tf)
for _, gf := range result.facts {
if err := enc.Encode(gf); err != nil {
return fmt.Errorf("failed gob encoding data: %w", err)
}
}
if _, err := tf.Seek(0, io.SeekStart); err != nil {
return err
}
a.vetx, err = r.writeCacheReader(a, "vetx", tf)
if err != nil {
return err
}
if a.factsOnly {
return nil
}
var out ResultData
out.Directives = make([]SerializedDirective, len(result.dirs))
for i, dir := range result.dirs {
out.Directives[i] = serializeDirective(dir, result.lpkg.Fset)
}
out.Diagnostics = result.diags
out.Unused = result.unused
a.results, err = r.writeCacheGob(a, "results", out)
if err != nil {
return err
}
}
return nil
}
// ActiveWorkers returns the number of currently running workers.
func (r *Runner) ActiveWorkers() int {
return r.semaphore.Len()
}
// TotalWorkers returns the maximum number of possible workers.
func (r *Runner) TotalWorkers() int {
return r.semaphore.Cap()
}
func (r *Runner) writeCacheReader(a *packageAction, kind string, rs io.ReadSeeker) (string, error) {
h := cache.Subkey(a.hash, kind)
out, _, err := r.cache.Put(h, rs)
if err != nil {
return "", fmt.Errorf("failed caching data: %w", err)
}
return r.cache.OutputFile(out), nil
}
func (r *Runner) writeCacheGob(a *packageAction, kind string, data interface{}) (string, error) {
f, err := ioutil.TempFile("", "staticcheck")
if err != nil {
return "", err
}
defer f.Close()
os.Remove(f.Name())
if err := gob.NewEncoder(f).Encode(data); err != nil {
return "", fmt.Errorf("failed gob encoding data: %w", err)
}
if _, err := f.Seek(0, io.SeekStart); err != nil {
return "", err
}
return r.writeCacheReader(a, kind, f)
}
type packageActionResult struct {
facts []gobFact
diags []Diagnostic
unused unused.SerializedResult
dirs []lint.Directive
lpkg *loader.Package
skipped bool
}
func (r *subrunner) doUncached(a *packageAction) (packageActionResult, error) {
// OPT(dh): for a -> b; c -> b; if both a and b are being
// processed concurrently, we shouldn't load b's export data
// twice.
pkg, _, err := loader.Load(a.Package)
if err != nil {
return packageActionResult{}, err
}
if len(pkg.Errors) > 0 {
// this handles errors that occurred during type-checking the
// package in loader.Load
for _, err := range pkg.Errors {
a.errors = append(a.errors, err)
}
a.failed = true
return packageActionResult{}, nil
}
if len(pkg.Syntax) == 0 && pkg.PkgPath != "unsafe" {
return packageActionResult{lpkg: pkg, skipped: true}, nil
}
// OPT(dh): instead of parsing directives twice (twice because
// U1000 depends on the facts.Directives analyzer), reuse the
// existing result
var dirs []lint.Directive
if !a.factsOnly {
dirs = lint.ParseDirectives(pkg.Syntax, pkg.Fset)
}
res, err := r.runAnalyzers(a, pkg)
return packageActionResult{
facts: res.facts,
diags: res.diagnostics,
unused: res.unused,
dirs: dirs,
lpkg: pkg,
}, err
}
func pkgPaths(root *types.Package) map[string]*types.Package {
out := map[string]*types.Package{}
var dfs func(*types.Package)
dfs = func(pkg *types.Package) {
if _, ok := out[pkg.Path()]; ok {
return
}
out[pkg.Path()] = pkg
for _, imp := range pkg.Imports() {
dfs(imp)
}
}
dfs(root)
return out
}
func (r *Runner) loadFacts(root *types.Package, dep *packageAction, objFacts map[objectFactKey]objectFact, pkgFacts map[packageFactKey]analysis.Fact) error {
// Load facts of all imported packages
vetx, err := os.Open(dep.vetx)
if err != nil {
return fmt.Errorf("failed loading cached facts: %w", err)
}
defer vetx.Close()
pathToPkg := pkgPaths(root)
dec := gob.NewDecoder(vetx)
for {
var gf gobFact
err := dec.Decode(&gf)
if err != nil {
if err == io.EOF {
break
}
return fmt.Errorf("failed loading cached facts: %w", err)
}
pkg, ok := pathToPkg[gf.PkgPath]
if !ok {
continue
}
if gf.ObjPath == "" {
pkgFacts[packageFactKey{
Pkg: pkg,
Type: reflect.TypeOf(gf.Fact),
}] = gf.Fact
} else {
obj, err := objectpath.Object(pkg, objectpath.Path(gf.ObjPath))
if err != nil {
continue
}
objFacts[objectFactKey{
Obj: obj,
Type: reflect.TypeOf(gf.Fact),
}] = objectFact{gf.Fact, objectpath.Path(gf.ObjPath)}
}
}
return nil
}
func genericHandle(a action, root action, queue chan action, sem *tsync.Semaphore, exec func(a action) error) {
if a == root {
close(queue)
if sem != nil {
sem.Release()
}
return
}
if !a.IsFailed() {
// the action may have already been marked as failed during
// construction of the action graph, for example because of
// unresolved imports.
for _, dep := range a.Deps() {
if dep.IsFailed() {
// One of our dependencies failed, so mark this package as
// failed and bail. We don't need to record an error for
// this package, the relevant error will have been
// reported by the first package in the chain that failed.
a.MarkFailed()
break
}
}
}
if !a.IsFailed() {
if err := exec(a); err != nil {
a.MarkFailed()
a.AddError(err)
}
}
if sem != nil {
sem.Release()
}
for _, t := range a.Triggers() {
if t.DecrementPending() {
queue <- t
}
}
}
type analyzerRunner struct {
pkg *loader.Package
// object facts of our dependencies; may contain facts of
// analyzers other than the current one
depObjFacts map[objectFactKey]objectFact
// package facts of our dependencies; may contain facts of
// analyzers other than the current one
depPkgFacts map[packageFactKey]analysis.Fact
factsOnly bool
stats *Stats
}
func (ar *analyzerRunner) do(act action) error {
a := act.(*analyzerAction)
results := map[*analysis.Analyzer]interface{}{}
// TODO(dh): does this have to be recursive?
for _, dep := range a.deps {
dep := dep.(*analyzerAction)
results[dep.Analyzer] = dep.Result
}
// OPT(dh): cache factTypes, it is the same for all packages for a given analyzer
//
// OPT(dh): do we need the factTypes map? most analyzers have 0-1
// fact types. iterating over the slice is probably faster than
// indexing a map.
factTypes := map[reflect.Type]struct{}{}
for _, typ := range a.Analyzer.FactTypes {
factTypes[reflect.TypeOf(typ)] = struct{}{}
}
filterFactType := func(typ reflect.Type) bool {
_, ok := factTypes[typ]
return ok
}
a.Pass = &analysis.Pass{
Analyzer: a.Analyzer,
Fset: ar.pkg.Fset,
Files: ar.pkg.Syntax,
OtherFiles: ar.pkg.OtherFiles,
Pkg: ar.pkg.Types,
TypesInfo: ar.pkg.TypesInfo,
TypesSizes: ar.pkg.TypesSizes,
Report: func(diag analysis.Diagnostic) {
if !ar.factsOnly {
if diag.Category == "" {
diag.Category = a.Analyzer.Name
}
d := Diagnostic{
Position: report.DisplayPosition(ar.pkg.Fset, diag.Pos),
End: report.DisplayPosition(ar.pkg.Fset, diag.End),
Category: diag.Category,
Message: diag.Message,
}
for _, sugg := range diag.SuggestedFixes {
s := SuggestedFix{
Message: sugg.Message,
}
for _, edit := range sugg.TextEdits {
s.TextEdits = append(s.TextEdits, TextEdit{
Position: report.DisplayPosition(ar.pkg.Fset, edit.Pos),
End: report.DisplayPosition(ar.pkg.Fset, edit.End),
NewText: edit.NewText,
})
}
d.SuggestedFixes = append(d.SuggestedFixes, s)
}
for _, rel := range diag.Related {
d.Related = append(d.Related, RelatedInformation{
Position: report.DisplayPosition(ar.pkg.Fset, rel.Pos),
End: report.DisplayPosition(ar.pkg.Fset, rel.End),
Message: rel.Message,
})
}
a.Diagnostics = append(a.Diagnostics, d)
}
},
ResultOf: results,
ImportObjectFact: func(obj types.Object, fact analysis.Fact) bool {
key := objectFactKey{
Obj: obj,
Type: reflect.TypeOf(fact),
}
if f, ok := ar.depObjFacts[key]; ok {
reflect.ValueOf(fact).Elem().Set(reflect.ValueOf(f.fact).Elem())
return true
} else if f, ok := a.ObjectFacts[key]; ok {
reflect.ValueOf(fact).Elem().Set(reflect.ValueOf(f.fact).Elem())
return true
}
return false
},
ImportPackageFact: func(pkg *types.Package, fact analysis.Fact) bool {
key := packageFactKey{
Pkg: pkg,
Type: reflect.TypeOf(fact),
}
if f, ok := ar.depPkgFacts[key]; ok {
reflect.ValueOf(fact).Elem().Set(reflect.ValueOf(f).Elem())
return true
} else if f, ok := a.PackageFacts[key]; ok {
reflect.ValueOf(fact).Elem().Set(reflect.ValueOf(f).Elem())
return true
}
return false
},
ExportObjectFact: func(obj types.Object, fact analysis.Fact) {
key := objectFactKey{
Obj: obj,
Type: reflect.TypeOf(fact),
}
path, _ := objectpath.For(obj)
a.ObjectFacts[key] = objectFact{fact, path}
},
ExportPackageFact: func(fact analysis.Fact) {
key := packageFactKey{
Pkg: ar.pkg.Types,
Type: reflect.TypeOf(fact),
}
a.PackageFacts[key] = fact
},
AllPackageFacts: func() []analysis.PackageFact {
out := make([]analysis.PackageFact, 0, len(ar.depPkgFacts)+len(a.PackageFacts))
for key, fact := range ar.depPkgFacts {
out = append(out, analysis.PackageFact{
Package: key.Pkg,
Fact: fact,
})
}
for key, fact := range a.PackageFacts {
out = append(out, analysis.PackageFact{
Package: key.Pkg,
Fact: fact,
})
}
return out
},
AllObjectFacts: func() []analysis.ObjectFact {
out := make([]analysis.ObjectFact, 0, len(ar.depObjFacts)+len(a.ObjectFacts))
for key, fact := range ar.depObjFacts {
if filterFactType(key.Type) {
out = append(out, analysis.ObjectFact{
Object: key.Obj,
Fact: fact.fact,
})
}
}
for key, fact := range a.ObjectFacts {
if filterFactType(key.Type) {
out = append(out, analysis.ObjectFact{
Object: key.Obj,
Fact: fact.fact,
})
}
}
return out
},
}
t := time.Now()
res, err := a.Analyzer.Run(a.Pass)
ar.stats.measureAnalyzer(a.Analyzer, ar.pkg.PackageSpec, time.Since(t))
if err != nil {
return err
}
a.Result = res
return nil
}
type analysisResult struct {
facts []gobFact
diagnostics []Diagnostic
unused unused.SerializedResult
}
func (r *subrunner) runAnalyzers(pkgAct *packageAction, pkg *loader.Package) (analysisResult, error) {
depObjFacts := map[objectFactKey]objectFact{}
depPkgFacts := map[packageFactKey]analysis.Fact{}
for _, dep := range pkgAct.deps {
if err := r.loadFacts(pkg.Types, dep.(*packageAction), depObjFacts, depPkgFacts); err != nil {
return analysisResult{}, err
}
}
root := &analyzerAction{}
var analyzers []*analysis.Analyzer
if pkgAct.factsOnly {
// When analyzing non-initial packages, we only care about
// analyzers that produce facts.
analyzers = r.factAnalyzers
} else {
analyzers = r.analyzers
}
all := map[*analysis.Analyzer]*analyzerAction{}
for _, a := range analyzers {
a := newAnalyzerAction(a, all)
root.deps = append(root.deps, a)
a.triggers = append(a.triggers, root)
}
root.pending = uint32(len(root.deps))
ar := &analyzerRunner{
pkg: pkg,
factsOnly: pkgAct.factsOnly,
depObjFacts: depObjFacts,
depPkgFacts: depPkgFacts,
stats: &r.Stats,
}
queue := make(chan action, len(all))
for _, a := range all {
if len(a.Deps()) == 0 {
queue <- a
}
}
// Don't hang if there are no analyzers to run; for example
// because we are analyzing a dependency but have no analyzers
// that produce facts.
if len(all) == 0 {
close(queue)
}
for item := range queue {
b := r.semaphore.AcquireMaybe()
if b {
go genericHandle(item, root, queue, &r.semaphore, ar.do)
} else {
// the semaphore is exhausted; run the analysis under the
// token we've acquired for analyzing the package.
genericHandle(item, root, queue, nil, ar.do)
}
}
var unusedResult unused.SerializedResult
for _, a := range all {
if a != root && a.Analyzer.Name == "U1000" {
// TODO(dh): figure out a clean abstraction, instead of
// special-casing U1000.
unusedResult = unused.Serialize(a.Pass, a.Result.(unused.Result), pkg.Fset)
}
for key, fact := range a.ObjectFacts {
depObjFacts[key] = fact
}
for key, fact := range a.PackageFacts {
depPkgFacts[key] = fact
}
}
// OPT(dh): cull objects not reachable via the exported closure
gobFacts := make([]gobFact, 0, len(depObjFacts)+len(depPkgFacts))
for key, fact := range depObjFacts {
if fact.path == "" {
continue
}
if sanityCheck {
p, _ := objectpath.For(key.Obj)
if p != fact.path {
panic(fmt.Sprintf("got different object paths for %v. old: %q new: %q", key.Obj, fact.path, p))
}
}
gf := gobFact{
PkgPath: key.Obj.Pkg().Path(),
ObjPath: string(fact.path),
Fact: fact.fact,
}
gobFacts = append(gobFacts, gf)
}
for key, fact := range depPkgFacts {
gf := gobFact{
PkgPath: key.Pkg.Path(),
Fact: fact,
}
gobFacts = append(gobFacts, gf)
}
var diags []Diagnostic
for _, a := range root.deps {
a := a.(*analyzerAction)
diags = append(diags, a.Diagnostics...)
}
return analysisResult{
facts: gobFacts,
diagnostics: diags,
unused: unusedResult,
}, nil
}
func registerGobTypes(analyzers []*analysis.Analyzer) {
for _, a := range analyzers {
for _, typ := range a.FactTypes {
// FIXME(dh): use RegisterName so we can work around collisions
// in names. For pointer-types, gob incorrectly qualifies
// type names with the package name, not the import path.
gob.Register(typ)
}
}
}
func allAnalyzers(analyzers []*analysis.Analyzer) []*analysis.Analyzer {
seen := map[*analysis.Analyzer]struct{}{}
out := make([]*analysis.Analyzer, 0, len(analyzers))
var dfs func(*analysis.Analyzer)
dfs = func(a *analysis.Analyzer) {
if _, ok := seen[a]; ok {
return
}
seen[a] = struct{}{}
out = append(out, a)
for _, dep := range a.Requires {
dfs(dep)
}
}
for _, a := range analyzers {
dfs(a)
}
return out
}
// Run loads the packages specified by patterns, runs analyzers on
// them and returns the results. Each result corresponds to a single
// package. Results will be returned for all packages, including
// dependencies. Errors specific to packages will be reported in the
// respective results.
//
// If cfg is nil, a default config will be used. Otherwise, cfg will
// be used, with the exception of the Mode field.
func (r *Runner) Run(cfg *packages.Config, analyzers []*analysis.Analyzer, patterns []string) ([]Result, error) {
analyzers = allAnalyzers(analyzers)
registerGobTypes(analyzers)
r.Stats.setState(StateLoadPackageGraph)
lpkgs, err := loader.Graph(r.cache, cfg, patterns...)
if err != nil {
return nil, err
}
r.Stats.setInitialPackages(len(lpkgs))
if len(lpkgs) == 0 {
return nil, nil
}
var goVersion string
if r.GoVersion == "module" {
for _, lpkg := range lpkgs {
if m := lpkg.Module; m != nil {
if goVersion == "" {
goVersion = m.GoVersion
} else if goVersion != m.GoVersion {
// Theoretically, we should only ever see a single Go
// module. At least that's currently (as of Go 1.15)
// true when using 'go list'.
fmt.Fprintln(os.Stderr, "warning: encountered multiple modules and could not deduce targeted Go version")
goVersion = ""
break
}
}
}
} else {
goVersion = r.GoVersion
}
if goVersion == "" {
if r.FallbackGoVersion == "" {
panic("could not determine Go version of module, and fallback version hasn't been set")
}
goVersion = r.FallbackGoVersion
}
r.actualGoVersion = goVersion
for _, a := range analyzers {
flag := a.Flags.Lookup("go")
if flag == nil {
continue
}
if err := flag.Value.Set(goVersion); err != nil {
return nil, err
}
}
r.Stats.setState(StateBuildActionGraph)
all := map[*loader.PackageSpec]*packageAction{}
root := &packageAction{}
for _, lpkg := range lpkgs {
a := newPackageActionRoot(lpkg, all)
root.deps = append(root.deps, a)
a.triggers = append(a.triggers, root)
}
root.pending = uint32(len(root.deps))
queue := make(chan action)
r.Stats.setTotalPackages(len(all) - 1)
r.Stats.setState(StateProcessing)
go func() {
for _, a := range all {
if len(a.Deps()) == 0 {
queue <- a
}
}
}()
sr := newSubrunner(r, analyzers)
for item := range queue {
r.semaphore.Acquire()
go genericHandle(item, root, queue, &r.semaphore, func(act action) error {
return sr.do(act)
})
}
r.Stats.setState(StateFinalizing)
out := make([]Result, 0, len(all))
for _, item := range all {
if item.Package == nil {
continue
}
out = append(out, Result{
Package: item.Package,
Config: item.cfg,
Initial: !item.factsOnly,
Skipped: item.skipped,
Failed: item.failed,
Errors: item.errors,
results: item.results,
})
}
return out, nil
}
go-tools-2021.1.2/lintcmd/runner/stats.go 0000664 0000000 0000000 00000003304 14143223131 0020124 0 ustar 00root root 0000000 0000000 package runner
import (
"sync/atomic"
"time"
"honnef.co/go/tools/go/loader"
"golang.org/x/tools/go/analysis"
)
const (
StateInitializing = iota
StateLoadPackageGraph
StateBuildActionGraph
StateProcessing
StateFinalizing
)
type Stats struct {
state uint32
initialPackages uint32
totalPackages uint32
processedPackages uint32
processedInitialPackages uint32
// optional function to call every time an analyzer has finished analyzing a package.
PrintAnalyzerMeasurement func(*analysis.Analyzer, *loader.PackageSpec, time.Duration)
}
func (s *Stats) setState(state uint32) { atomic.StoreUint32(&s.state, state) }
func (s *Stats) State() int { return int(atomic.LoadUint32(&s.state)) }
func (s *Stats) setInitialPackages(n int) { atomic.StoreUint32(&s.initialPackages, uint32(n)) }
func (s *Stats) InitialPackages() int { return int(atomic.LoadUint32(&s.initialPackages)) }
func (s *Stats) setTotalPackages(n int) { atomic.StoreUint32(&s.totalPackages, uint32(n)) }
func (s *Stats) TotalPackages() int { return int(atomic.LoadUint32(&s.totalPackages)) }
func (s *Stats) finishPackage() { atomic.AddUint32(&s.processedPackages, 1) }
func (s *Stats) finishInitialPackage() { atomic.AddUint32(&s.processedInitialPackages, 1) }
func (s *Stats) ProcessedPackages() int { return int(atomic.LoadUint32(&s.processedPackages)) }
func (s *Stats) ProcessedInitialPackages() int {
return int(atomic.LoadUint32(&s.processedInitialPackages))
}
func (s *Stats) measureAnalyzer(analysis *analysis.Analyzer, pkg *loader.PackageSpec, d time.Duration) {
if s.PrintAnalyzerMeasurement != nil {
s.PrintAnalyzerMeasurement(analysis, pkg, d)
}
}
go-tools-2021.1.2/lintcmd/stats.go 0000664 0000000 0000000 00000000224 14143223131 0016611 0 ustar 00root root 0000000 0000000 // +build !aix,!android,!darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!solaris
package lintcmd
import "os"
var infoSignals = []os.Signal{}
go-tools-2021.1.2/lintcmd/stats_bsd.go 0000664 0000000 0000000 00000000220 14143223131 0017435 0 ustar 00root root 0000000 0000000 // +build darwin dragonfly freebsd netbsd openbsd
package lintcmd
import (
"os"
"syscall"
)
var infoSignals = []os.Signal{syscall.SIGINFO}
go-tools-2021.1.2/lintcmd/stats_posix.go 0000664 0000000 0000000 00000000202 14143223131 0020027 0 ustar 00root root 0000000 0000000 // +build aix android linux solaris
package lintcmd
import (
"os"
"syscall"
)
var infoSignals = []os.Signal{syscall.SIGUSR1}
go-tools-2021.1.2/lintcmd/testdata/ 0000775 0000000 0000000 00000000000 14143223131 0016737 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/lintcmd/testdata/src/ 0000775 0000000 0000000 00000000000 14143223131 0017526 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/lintcmd/testdata/src/Test/ 0000775 0000000 0000000 00000000000 14143223131 0020445 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/lintcmd/testdata/src/Test/file-ignores.go 0000664 0000000 0000000 00000000230 14143223131 0023352 0 ustar 00root root 0000000 0000000 package pkg
//lint:file-ignore TEST1000 File-wide ignore
// the line directive should not affect the line ignores
//line random-file:1
func fn5() {}
go-tools-2021.1.2/lintcmd/testdata/src/Test/line-ignores.go 0000664 0000000 0000000 00000001010 14143223131 0023357 0 ustar 00root root 0000000 0000000 package pkg
// the line directive should not affect the line ignores
//line random-file:1
func fn1() {} // want `test problem`
//lint:ignore TEST1000 This should be ignored, because ...
//lint:ignore XXX1000 Testing that multiple linter directives work correctly
func fn2() {}
//lint:ignore TEST1000 // want `malformed linter directive`
func fn3() {} // want `test problem`
//lint:ignore TEST1000 ignore
func fn4() {
//lint:ignore TEST1000 ignore // want `this linter directive didn't match anything`
var _ int
}
go-tools-2021.1.2/lintcmd/testdata/src/broken_dep/ 0000775 0000000 0000000 00000000000 14143223131 0021636 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/lintcmd/testdata/src/broken_dep/pkg.go 0000664 0000000 0000000 00000000050 14143223131 0022741 0 ustar 00root root 0000000 0000000 package pkg
import _ "unknown_package"
go-tools-2021.1.2/lintcmd/testdata/src/broken_parse/ 0000775 0000000 0000000 00000000000 14143223131 0022200 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/lintcmd/testdata/src/broken_parse/pkg.go 0000664 0000000 0000000 00000000021 14143223131 0023301 0 ustar 00root root 0000000 0000000 package pkg
asd
go-tools-2021.1.2/lintcmd/testdata/src/broken_pkgerror/ 0000775 0000000 0000000 00000000000 14143223131 0022721 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/lintcmd/testdata/src/broken_pkgerror/broken.go 0000664 0000000 0000000 00000000013 14143223131 0024522 0 ustar 00root root 0000000 0000000 pckage pkg
go-tools-2021.1.2/lintcmd/testdata/src/broken_typeerror/ 0000775 0000000 0000000 00000000000 14143223131 0023121 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/lintcmd/testdata/src/broken_typeerror/pkg.go 0000664 0000000 0000000 00000000057 14143223131 0024233 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
x := 1
_ = x + ""
}
go-tools-2021.1.2/lintcmd/version/ 0000775 0000000 0000000 00000000000 14143223131 0016613 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/lintcmd/version/buildinfo.go 0000664 0000000 0000000 00000001460 14143223131 0021116 0 ustar 00root root 0000000 0000000 // +build go1.12
package version
import (
"fmt"
"runtime/debug"
)
func printBuildInfo() {
if info, ok := debug.ReadBuildInfo(); ok {
fmt.Println("Main module:")
printModule(&info.Main)
fmt.Println("Dependencies:")
for _, dep := range info.Deps {
printModule(dep)
}
} else {
fmt.Println("Built without Go modules")
}
}
func buildInfoVersion() (string, bool) {
info, ok := debug.ReadBuildInfo()
if !ok {
return "", false
}
if info.Main.Version == "(devel)" {
return "", false
}
return info.Main.Version, true
}
func printModule(m *debug.Module) {
fmt.Printf("\t%s", m.Path)
if m.Version != "(devel)" {
fmt.Printf("@%s", m.Version)
}
if m.Sum != "" {
fmt.Printf(" (sum: %s)", m.Sum)
}
if m.Replace != nil {
fmt.Printf(" (replace: %s)", m.Replace.Path)
}
fmt.Println()
}
go-tools-2021.1.2/lintcmd/version/buildinfo111.go 0000664 0000000 0000000 00000000212 14143223131 0021333 0 ustar 00root root 0000000 0000000 // +build !go1.12
package version
func printBuildInfo() {}
func buildInfoVersion() (string, bool) { return "", false }
go-tools-2021.1.2/lintcmd/version/version.go 0000664 0000000 0000000 00000001674 14143223131 0020637 0 ustar 00root root 0000000 0000000 package version
import (
"fmt"
"os"
"path/filepath"
"runtime"
)
const Version = "2021.1.2"
const MachineVersion = "v0.2.2"
// version returns a version descriptor and reports whether the
// version is a known release.
func version(human, machine string) (human_, machine_ string, known bool) {
if human != "devel" {
return human, machine, true
}
v, ok := buildInfoVersion()
if ok {
return v, "", false
}
return "devel", "", false
}
func Print(human, machine string) {
human, machine, release := version(human, machine)
if release {
fmt.Printf("%s %s (%s)\n", filepath.Base(os.Args[0]), human, machine)
} else if human == "devel" {
fmt.Printf("%s (no version)\n", filepath.Base(os.Args[0]))
} else {
fmt.Printf("%s (devel, %s)\n", filepath.Base(os.Args[0]), human)
}
}
func Verbose(human, machine string) {
Print(human, machine)
fmt.Println()
fmt.Println("Compiled with Go version:", runtime.Version())
printBuildInfo()
}
go-tools-2021.1.2/pattern/ 0000775 0000000 0000000 00000000000 14143223131 0015151 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/pattern/convert.go 0000664 0000000 0000000 00000014534 14143223131 0017167 0 ustar 00root root 0000000 0000000 package pattern
import (
"fmt"
"go/ast"
"go/token"
"go/types"
"reflect"
)
var astTypes = map[string]reflect.Type{
"Ellipsis": reflect.TypeOf(ast.Ellipsis{}),
"RangeStmt": reflect.TypeOf(ast.RangeStmt{}),
"AssignStmt": reflect.TypeOf(ast.AssignStmt{}),
"IndexExpr": reflect.TypeOf(ast.IndexExpr{}),
"Ident": reflect.TypeOf(ast.Ident{}),
"ValueSpec": reflect.TypeOf(ast.ValueSpec{}),
"GenDecl": reflect.TypeOf(ast.GenDecl{}),
"BinaryExpr": reflect.TypeOf(ast.BinaryExpr{}),
"ForStmt": reflect.TypeOf(ast.ForStmt{}),
"ArrayType": reflect.TypeOf(ast.ArrayType{}),
"DeferStmt": reflect.TypeOf(ast.DeferStmt{}),
"MapType": reflect.TypeOf(ast.MapType{}),
"ReturnStmt": reflect.TypeOf(ast.ReturnStmt{}),
"SliceExpr": reflect.TypeOf(ast.SliceExpr{}),
"StarExpr": reflect.TypeOf(ast.StarExpr{}),
"UnaryExpr": reflect.TypeOf(ast.UnaryExpr{}),
"SendStmt": reflect.TypeOf(ast.SendStmt{}),
"SelectStmt": reflect.TypeOf(ast.SelectStmt{}),
"ImportSpec": reflect.TypeOf(ast.ImportSpec{}),
"IfStmt": reflect.TypeOf(ast.IfStmt{}),
"GoStmt": reflect.TypeOf(ast.GoStmt{}),
"Field": reflect.TypeOf(ast.Field{}),
"SelectorExpr": reflect.TypeOf(ast.SelectorExpr{}),
"StructType": reflect.TypeOf(ast.StructType{}),
"KeyValueExpr": reflect.TypeOf(ast.KeyValueExpr{}),
"FuncType": reflect.TypeOf(ast.FuncType{}),
"FuncLit": reflect.TypeOf(ast.FuncLit{}),
"FuncDecl": reflect.TypeOf(ast.FuncDecl{}),
"ChanType": reflect.TypeOf(ast.ChanType{}),
"CallExpr": reflect.TypeOf(ast.CallExpr{}),
"CaseClause": reflect.TypeOf(ast.CaseClause{}),
"CommClause": reflect.TypeOf(ast.CommClause{}),
"CompositeLit": reflect.TypeOf(ast.CompositeLit{}),
"EmptyStmt": reflect.TypeOf(ast.EmptyStmt{}),
"SwitchStmt": reflect.TypeOf(ast.SwitchStmt{}),
"TypeSwitchStmt": reflect.TypeOf(ast.TypeSwitchStmt{}),
"TypeAssertExpr": reflect.TypeOf(ast.TypeAssertExpr{}),
"TypeSpec": reflect.TypeOf(ast.TypeSpec{}),
"InterfaceType": reflect.TypeOf(ast.InterfaceType{}),
"BranchStmt": reflect.TypeOf(ast.BranchStmt{}),
"IncDecStmt": reflect.TypeOf(ast.IncDecStmt{}),
"BasicLit": reflect.TypeOf(ast.BasicLit{}),
}
func ASTToNode(node interface{}) Node {
switch node := node.(type) {
case *ast.File:
panic("cannot convert *ast.File to Node")
case nil:
return Nil{}
case string:
return String(node)
case token.Token:
return Token(node)
case *ast.ExprStmt:
return ASTToNode(node.X)
case *ast.BlockStmt:
if node == nil {
return Nil{}
}
return ASTToNode(node.List)
case *ast.FieldList:
if node == nil {
return Nil{}
}
return ASTToNode(node.List)
case *ast.BasicLit:
if node == nil {
return Nil{}
}
case *ast.ParenExpr:
return ASTToNode(node.X)
}
if node, ok := node.(ast.Node); ok {
name := reflect.TypeOf(node).Elem().Name()
T, ok := structNodes[name]
if !ok {
panic(fmt.Sprintf("internal error: unhandled type %T", node))
}
if reflect.ValueOf(node).IsNil() {
return Nil{}
}
v := reflect.ValueOf(node).Elem()
objs := make([]Node, T.NumField())
for i := 0; i < T.NumField(); i++ {
f := v.FieldByName(T.Field(i).Name)
objs[i] = ASTToNode(f.Interface())
}
n, err := populateNode(name, objs, false)
if err != nil {
panic(fmt.Sprintf("internal error: %s", err))
}
return n
}
s := reflect.ValueOf(node)
if s.Kind() == reflect.Slice {
if s.Len() == 0 {
return List{}
}
if s.Len() == 1 {
return ASTToNode(s.Index(0).Interface())
}
tail := List{}
for i := s.Len() - 1; i >= 0; i-- {
head := ASTToNode(s.Index(i).Interface())
l := List{
Head: head,
Tail: tail,
}
tail = l
}
return tail
}
panic(fmt.Sprintf("internal error: unhandled type %T", node))
}
func NodeToAST(node Node, state State) interface{} {
switch node := node.(type) {
case Binding:
v, ok := state[node.Name]
if !ok {
// really we want to return an error here
panic("XXX")
}
switch v := v.(type) {
case types.Object:
return &ast.Ident{Name: v.Name()}
default:
return v
}
case Builtin, Any, Object, Function, Not, Or:
panic("XXX")
case List:
if (node == List{}) {
return []ast.Node{}
}
x := []ast.Node{NodeToAST(node.Head, state).(ast.Node)}
x = append(x, NodeToAST(node.Tail, state).([]ast.Node)...)
return x
case Token:
return token.Token(node)
case String:
return string(node)
case Nil:
return nil
}
name := reflect.TypeOf(node).Name()
T, ok := astTypes[name]
if !ok {
panic(fmt.Sprintf("internal error: unhandled type %T", node))
}
v := reflect.ValueOf(node)
out := reflect.New(T)
for i := 0; i < T.NumField(); i++ {
fNode := v.FieldByName(T.Field(i).Name)
if (fNode == reflect.Value{}) {
continue
}
fAST := out.Elem().FieldByName(T.Field(i).Name)
switch fAST.Type().Kind() {
case reflect.Slice:
c := reflect.ValueOf(NodeToAST(fNode.Interface().(Node), state))
if c.Kind() != reflect.Slice {
// it's a single node in the pattern, we have to wrap
// it in a slice
slice := reflect.MakeSlice(fAST.Type(), 1, 1)
slice.Index(0).Set(c)
c = slice
}
switch fAST.Interface().(type) {
case []ast.Node:
switch cc := c.Interface().(type) {
case []ast.Node:
fAST.Set(c)
case []ast.Expr:
var slice []ast.Node
for _, el := range cc {
slice = append(slice, el)
}
fAST.Set(reflect.ValueOf(slice))
default:
panic("XXX")
}
case []ast.Expr:
switch cc := c.Interface().(type) {
case []ast.Node:
var slice []ast.Expr
for _, el := range cc {
slice = append(slice, el.(ast.Expr))
}
fAST.Set(reflect.ValueOf(slice))
case []ast.Expr:
fAST.Set(c)
default:
panic("XXX")
}
default:
panic("XXX")
}
case reflect.Int:
c := reflect.ValueOf(NodeToAST(fNode.Interface().(Node), state))
switch c.Kind() {
case reflect.String:
tok, ok := tokensByString[c.Interface().(string)]
if !ok {
// really we want to return an error here
panic("XXX")
}
fAST.SetInt(int64(tok))
case reflect.Int:
fAST.Set(c)
default:
panic(fmt.Sprintf("internal error: unexpected kind %s", c.Kind()))
}
default:
r := NodeToAST(fNode.Interface().(Node), state)
if r != nil {
fAST.Set(reflect.ValueOf(r))
}
}
}
return out.Interface().(ast.Node)
}
go-tools-2021.1.2/pattern/doc.go 0000664 0000000 0000000 00000025376 14143223131 0016262 0 ustar 00root root 0000000 0000000 /*
Package pattern implements a simple language for pattern matching Go ASTs.
Design decisions and trade-offs
The language is designed specifically for the task of filtering ASTs
to simplify the implementation of analyses in staticcheck.
It is also intended to be trivial to parse and execute.
To that end, we make certain decisions that make the language more
suited to its task, while making certain queries infeasible.
Furthermore, it is fully expected that the majority of analyses will still require ordinary Go code
to further process the filtered AST, to make use of type information and to enforce complex invariants.
It is not our goal to design a scripting language for writing entire checks in.
The language
At its core, patterns are a representation of Go ASTs, allowing for the use of placeholders to enable pattern matching.
Their syntax is inspired by LISP and Haskell, but unlike LISP, the core unit of patterns isn't the list, but the node.
There is a fixed set of nodes, identified by name, and with the exception of the Or node, all nodes have a fixed number of arguments.
In addition to nodes, there are atoms, which represent basic units such as strings or the nil value.
Pattern matching is implemented via bindings, represented by the Binding node.
A Binding can match nodes and associate them with names, to later recall the nodes.
This allows for expressing "this node must be equal to that node" constraints.
To simplify writing and reading patterns, a small amount of additional syntax exists on top of nodes and atoms.
This additional syntax doesn't add any new features of its own, it simply provides shortcuts to creating nodes and atoms.
To show an example of a pattern, first consider this snippet of Go code:
if x := fn(); x != nil {
for _, v := range x {
println(v, x)
}
}
The corresponding AST expressed as an idiomatic pattern would look as follows:
(IfStmt
(AssignStmt (Ident "x") ":=" (CallExpr (Ident "fn") []))
(BinaryExpr (Ident "x") "!=" (Ident "nil"))
(RangeStmt
(Ident "_") (Ident "v") ":=" (Ident "x")
(CallExpr (Ident "println") [(Ident "v") (Ident "x")]))
nil)
Two things are worth noting about this representation.
First, the [el1 el2 ...] syntax is a short-hand for creating lists.
It is a short-hand for el1:el2:[], which itself is a short-hand for (List el1 (List el2 (List nil nil)).
Second, note the absence of a lot of lists in places that normally accept lists.
For example, assignment assigns a number of right-hands to a number of left-hands, yet our AssignStmt is lacking any form of list.
This is due to the fact that a single node can match a list of exactly one element.
Thus, the two following forms have identical matching behavior:
(AssignStmt (Ident "x") ":=" (CallExpr (Ident "fn") []))
(AssignStmt [(Ident "x")] ":=" [(CallExpr (Ident "fn") [])])
This section serves as an overview of the language's syntax.
More in-depth explanations of the matching behavior as well as an exhaustive list of node types follows in the coming sections.
Pattern matching
TODO write about pattern matching
- inspired by haskell syntax, but much, much simpler and naive
Node types
The language contains two kinds of nodes: those that map to nodes in the AST, and those that implement additional logic.
Nodes that map directly to AST nodes are named identically to the types in the go/ast package.
What follows is an exhaustive list of these nodes:
(ArrayType len elt)
(AssignStmt lhs tok rhs)
(BasicLit kind value)
(BinaryExpr x op y)
(BranchStmt tok label)
(CallExpr fun args)
(CaseClause list body)
(ChanType dir value)
(CommClause comm body)
(CompositeLit type elts)
(DeferStmt call)
(Ellipsis elt)
(EmptyStmt)
(Field names type tag)
(ForStmt init cond post body)
(FuncDecl recv name type body)
(FuncLit type body)
(FuncType params results)
(GenDecl specs)
(GoStmt call)
(Ident name)
(IfStmt init cond body else)
(ImportSpec name path)
(IncDecStmt x tok)
(IndexExpr x index)
(InterfaceType methods)
(KeyValueExpr key value)
(MapType key value)
(RangeStmt key value tok x body)
(ReturnStmt results)
(SelectStmt body)
(SelectorExpr x sel)
(SendStmt chan value)
(SliceExpr x low high max)
(StarExpr x)
(StructType fields)
(SwitchStmt init tag body)
(TypeAssertExpr)
(TypeSpec name type)
(TypeSwitchStmt init assign body)
(UnaryExpr op x)
(ValueSpec names type values)
Additionally, there are the String, Token and nil atoms.
Strings are double-quoted string literals, as in (Ident "someName").
Tokens are also represented as double-quoted string literals, but are converted to token.Token values in contexts that require tokens,
such as in (BinaryExpr x "<" y), where "<" is transparently converted to token.LSS during matching.
The keyword 'nil' denotes the nil value, which represents the absence of any value.
We also define the (List head tail) node, which is used to represent sequences of elements as a singly linked list.
The head is a single element, and the tail is the remainder of the list.
For example,
(List "foo" (List "bar" (List "baz" (List nil nil))))
represents a list of three elements, "foo", "bar" and "baz". There is dedicated syntax for writing lists, which looks as follows:
["foo" "bar" "baz"]
This syntax is itself syntactic sugar for the following form:
"foo":"bar":"baz":[]
This form is of particular interest for pattern matching, as it allows matching on the head and tail. For example,
"foo":"bar":_
would match any list with at least two elements, where the first two elements are "foo" and "bar". This is equivalent to writing
(List "foo" (List "bar" _))
Note that it is not possible to match from the end of the list.
That is, there is no way to express a query such as "a list of any length where the last element is foo".
Note that unlike in LISP, nil and empty lists are distinct from one another.
In patterns, with respect to lists, nil is akin to Go's untyped nil.
It will match a nil ast.Node, but it will not match a nil []ast.Expr. Nil will, however, match pointers to named types such as *ast.Ident.
Similarly, lists are akin to Go's
slices. An empty list will match both a nil and an empty []ast.Expr, but it will not match a nil ast.Node.
Due to the difference between nil and empty lists, an empty list is represented as (List nil nil), i.e. a list with no head or tail.
Similarly, a list of one element is represented as (List el (List nil nil)). Unlike in LISP, it cannot be represented by (List el nil).
Finally, there are nodes that implement special logic or matching behavior.
(Any) matches any value. The underscore (_) maps to this node, making the following two forms equivalent:
(Ident _)
(Ident (Any))
(Builtin name) matches a built-in identifier or function by name.
This is a type-aware variant of (Ident name).
Instead of only comparing the name, it resolves the object behind the name and makes sure it's a pre-declared identifier.
For example, in the following piece of code
func fn() {
println(true)
true := false
println(true)
}
the pattern
(Builtin "true")
will match exactly once, on the first use of 'true' in the function.
Subsequent occurrences of 'true' no longer refer to the pre-declared identifier.
(Object name) matches an identifier by name, but yields the
types.Object it refers to.
(Function name) matches ast.Idents and ast.SelectorExprs that refer to a function with a given fully qualified name.
For example, "net/url.PathEscape" matches the PathEscape function in the net/url package,
and "(net/url.EscapeError).Error" refers to the Error method on the net/url.EscapeError type,
either on an instance of the type, or on the type itself.
For example, the following patterns match the following lines of code:
(CallExpr (Function "fmt.Println") _) // pattern 1
(CallExpr (Function "(net/url.EscapeError).Error") _) // pattern 2
fmt.Println("hello, world") // matches pattern 1
var x url.EscapeError
x.Error() // matches pattern 2
(url.EscapeError).Error(x) // also matches pattern 2
(Binding name node) creates or uses a binding.
Bindings work like variable assignments, allowing referring to already matched nodes.
As an example, bindings are necessary to match self-assignment of the form "x = x",
since we need to express that the right-hand side is identical to the left-hand side.
If a binding's node is not nil, the matcher will attempt to match a node according to the pattern.
If a binding's node is nil, the binding will either recall an existing value, or match the Any node.
It is an error to provide a non-nil node to a binding that has already been bound.
Referring back to the earlier example, the following pattern will match self-assignment of idents:
(AssignStmt (Binding "lhs" (Ident _)) "=" (Binding "lhs" nil))
Because bindings are a crucial component of pattern matching, there is special syntax for creating and recalling bindings.
Lower-case names refer to bindings. If standing on its own, the name "foo" will be equivalent to (Binding "foo" nil).
If a name is followed by an at-sign (@) then it will create a binding for the node that follows.
Together, this allows us to rewrite the earlier example as follows:
(AssignStmt lhs@(Ident _) "=" lhs)
(Or nodes...) is a variadic node that tries matching each node until one succeeds. For example, the following pattern matches all idents of name "foo" or "bar":
(Ident (Or "foo" "bar"))
We could also have written
(Or (Ident "foo") (Ident "bar"))
and achieved the same result. We can also mix different kinds of nodes:
(Or (Ident "foo") (CallExpr (Ident "bar") _))
When using bindings inside of nodes used inside Or, all or none of the bindings will be bound.
That is, partially matched nodes that ultimately failed to match will not produce any bindings observable outside of the matching attempt.
We can thus write
(Or (Ident name) (CallExpr name))
and 'name' will either be a String if the first option matched, or an Ident or SelectorExpr if the second option matched.
(Not node)
The Not node negates a match. For example, (Not (Ident _)) will match all nodes that aren't identifiers.
ChanDir(0)
Automatic unnesting of AST nodes
The Go AST has several types of nodes that wrap other nodes.
To simplify matching, we automatically unwrap some of these nodes.
These nodes are ExprStmt (for using expressions in a statement context),
ParenExpr (for parenthesized expressions),
DeclStmt (for declarations in a statement context),
and LabeledStmt (for labeled statements).
Thus, the query
(FuncLit _ [(CallExpr _ _)]
will match a function literal containing a single function call,
even though in the actual Go AST, the CallExpr is nested inside an ExprStmt,
as function bodies are made up of sequences of statements.
On the flip-side, there is no way to specifically match these wrapper nodes.
For example, there is no way of searching for unnecessary parentheses, like in the following piece of Go code:
((x)) += 2
*/
package pattern
go-tools-2021.1.2/pattern/fuzz.go 0000664 0000000 0000000 00000001442 14143223131 0016477 0 ustar 00root root 0000000 0000000 // +build gofuzz
package pattern
import (
"go/ast"
goparser "go/parser"
"go/token"
"os"
"path/filepath"
"strings"
)
var files []*ast.File
func init() {
fset := token.NewFileSet()
filepath.Walk("/usr/lib/go/src", func(path string, info os.FileInfo, err error) error {
if err != nil {
// XXX error handling
panic(err)
}
if !strings.HasSuffix(path, ".go") {
return nil
}
f, err := goparser.ParseFile(fset, path, nil, 0)
if err != nil {
return nil
}
files = append(files, f)
return nil
})
}
func Fuzz(data []byte) int {
p := &Parser{}
pat, err := p.Parse(string(data))
if err != nil {
if strings.Contains(err.Error(), "internal error") {
panic(err)
}
return 0
}
_ = pat.Root.String()
for _, f := range files {
Match(pat.Root, f)
}
return 1
}
go-tools-2021.1.2/pattern/lexer.go 0000664 0000000 0000000 00000006554 14143223131 0016631 0 ustar 00root root 0000000 0000000 package pattern
import (
"fmt"
"go/token"
"unicode"
"unicode/utf8"
)
type lexer struct {
f *token.File
input string
start int
pos int
width int
items chan item
}
type itemType int
const eof = -1
const (
itemError itemType = iota
itemLeftParen
itemRightParen
itemLeftBracket
itemRightBracket
itemTypeName
itemVariable
itemAt
itemColon
itemBlank
itemString
itemEOF
)
func (typ itemType) String() string {
switch typ {
case itemError:
return "ERROR"
case itemLeftParen:
return "("
case itemRightParen:
return ")"
case itemLeftBracket:
return "["
case itemRightBracket:
return "]"
case itemTypeName:
return "TYPE"
case itemVariable:
return "VAR"
case itemAt:
return "@"
case itemColon:
return ":"
case itemBlank:
return "_"
case itemString:
return "STRING"
case itemEOF:
return "EOF"
default:
return fmt.Sprintf("itemType(%d)", typ)
}
}
type item struct {
typ itemType
val string
pos int
}
type stateFn func(*lexer) stateFn
func (l *lexer) run() {
for state := lexStart; state != nil; {
state = state(l)
}
close(l.items)
}
func (l *lexer) emitValue(t itemType, value string) {
l.items <- item{t, value, l.start}
l.start = l.pos
}
func (l *lexer) emit(t itemType) {
l.items <- item{t, l.input[l.start:l.pos], l.start}
l.start = l.pos
}
func lexStart(l *lexer) stateFn {
switch r := l.next(); {
case r == eof:
l.emit(itemEOF)
return nil
case unicode.IsSpace(r):
l.ignore()
case r == '(':
l.emit(itemLeftParen)
case r == ')':
l.emit(itemRightParen)
case r == '[':
l.emit(itemLeftBracket)
case r == ']':
l.emit(itemRightBracket)
case r == '@':
l.emit(itemAt)
case r == ':':
l.emit(itemColon)
case r == '_':
l.emit(itemBlank)
case r == '"':
l.backup()
return lexString
case unicode.IsUpper(r):
l.backup()
return lexType
case unicode.IsLower(r):
l.backup()
return lexVariable
default:
return l.errorf("unexpected character %c", r)
}
return lexStart
}
func (l *lexer) next() (r rune) {
if l.pos >= len(l.input) {
l.width = 0
return eof
}
r, l.width = utf8.DecodeRuneInString(l.input[l.pos:])
if r == '\n' {
l.f.AddLine(l.pos)
}
l.pos += l.width
return r
}
func (l *lexer) ignore() {
l.start = l.pos
}
func (l *lexer) backup() {
l.pos -= l.width
}
func (l *lexer) errorf(format string, args ...interface{}) stateFn {
// TODO(dh): emit position information in errors
l.items <- item{
itemError,
fmt.Sprintf(format, args...),
l.start,
}
return nil
}
func isAlphaNumeric(r rune) bool {
return r >= '0' && r <= '9' ||
r >= 'a' && r <= 'z' ||
r >= 'A' && r <= 'Z'
}
func lexString(l *lexer) stateFn {
l.next() // skip quote
escape := false
var runes []rune
for {
switch r := l.next(); r {
case eof:
return l.errorf("unterminated string")
case '"':
if !escape {
l.emitValue(itemString, string(runes))
return lexStart
} else {
runes = append(runes, '"')
escape = false
}
case '\\':
if escape {
runes = append(runes, '\\')
escape = false
} else {
escape = true
}
default:
runes = append(runes, r)
}
}
}
func lexType(l *lexer) stateFn {
l.next()
for {
if !isAlphaNumeric(l.next()) {
l.backup()
l.emit(itemTypeName)
return lexStart
}
}
}
func lexVariable(l *lexer) stateFn {
l.next()
for {
if !isAlphaNumeric(l.next()) {
l.backup()
l.emit(itemVariable)
return lexStart
}
}
}
go-tools-2021.1.2/pattern/match.go 0000664 0000000 0000000 00000027561 14143223131 0016607 0 ustar 00root root 0000000 0000000 package pattern
import (
"fmt"
"go/ast"
"go/token"
"go/types"
"reflect"
)
var tokensByString = map[string]Token{
"INT": Token(token.INT),
"FLOAT": Token(token.FLOAT),
"IMAG": Token(token.IMAG),
"CHAR": Token(token.CHAR),
"STRING": Token(token.STRING),
"+": Token(token.ADD),
"-": Token(token.SUB),
"*": Token(token.MUL),
"/": Token(token.QUO),
"%": Token(token.REM),
"&": Token(token.AND),
"|": Token(token.OR),
"^": Token(token.XOR),
"<<": Token(token.SHL),
">>": Token(token.SHR),
"&^": Token(token.AND_NOT),
"+=": Token(token.ADD_ASSIGN),
"-=": Token(token.SUB_ASSIGN),
"*=": Token(token.MUL_ASSIGN),
"/=": Token(token.QUO_ASSIGN),
"%=": Token(token.REM_ASSIGN),
"&=": Token(token.AND_ASSIGN),
"|=": Token(token.OR_ASSIGN),
"^=": Token(token.XOR_ASSIGN),
"<<=": Token(token.SHL_ASSIGN),
">>=": Token(token.SHR_ASSIGN),
"&^=": Token(token.AND_NOT_ASSIGN),
"&&": Token(token.LAND),
"||": Token(token.LOR),
"<-": Token(token.ARROW),
"++": Token(token.INC),
"--": Token(token.DEC),
"==": Token(token.EQL),
"<": Token(token.LSS),
">": Token(token.GTR),
"=": Token(token.ASSIGN),
"!": Token(token.NOT),
"!=": Token(token.NEQ),
"<=": Token(token.LEQ),
">=": Token(token.GEQ),
":=": Token(token.DEFINE),
"...": Token(token.ELLIPSIS),
"IMPORT": Token(token.IMPORT),
"VAR": Token(token.VAR),
"TYPE": Token(token.TYPE),
"CONST": Token(token.CONST),
"BREAK": Token(token.BREAK),
"CONTINUE": Token(token.CONTINUE),
"GOTO": Token(token.GOTO),
"FALLTHROUGH": Token(token.FALLTHROUGH),
}
func maybeToken(node Node) (Node, bool) {
if node, ok := node.(String); ok {
if tok, ok := tokensByString[string(node)]; ok {
return tok, true
}
return node, false
}
return node, false
}
func isNil(v interface{}) bool {
if v == nil {
return true
}
if _, ok := v.(Nil); ok {
return true
}
return false
}
type matcher interface {
Match(*Matcher, interface{}) (interface{}, bool)
}
type State = map[string]interface{}
type Matcher struct {
TypesInfo *types.Info
State State
}
func (m *Matcher) fork() *Matcher {
state := make(State, len(m.State))
for k, v := range m.State {
state[k] = v
}
return &Matcher{
TypesInfo: m.TypesInfo,
State: state,
}
}
func (m *Matcher) merge(mc *Matcher) {
m.State = mc.State
}
func (m *Matcher) Match(a Node, b ast.Node) bool {
m.State = State{}
_, ok := match(m, a, b)
return ok
}
func Match(a Node, b ast.Node) (*Matcher, bool) {
m := &Matcher{}
ret := m.Match(a, b)
return m, ret
}
// Match two items, which may be (Node, AST) or (AST, AST)
func match(m *Matcher, l, r interface{}) (interface{}, bool) {
if _, ok := r.(Node); ok {
panic("Node mustn't be on right side of match")
}
switch l := l.(type) {
case *ast.ParenExpr:
return match(m, l.X, r)
case *ast.ExprStmt:
return match(m, l.X, r)
case *ast.DeclStmt:
return match(m, l.Decl, r)
case *ast.LabeledStmt:
return match(m, l.Stmt, r)
case *ast.BlockStmt:
return match(m, l.List, r)
case *ast.FieldList:
return match(m, l.List, r)
}
switch r := r.(type) {
case *ast.ParenExpr:
return match(m, l, r.X)
case *ast.ExprStmt:
return match(m, l, r.X)
case *ast.DeclStmt:
return match(m, l, r.Decl)
case *ast.LabeledStmt:
return match(m, l, r.Stmt)
case *ast.BlockStmt:
if r == nil {
return match(m, l, nil)
}
return match(m, l, r.List)
case *ast.FieldList:
if r == nil {
return match(m, l, nil)
}
return match(m, l, r.List)
case *ast.BasicLit:
if r == nil {
return match(m, l, nil)
}
}
if l, ok := l.(matcher); ok {
return l.Match(m, r)
}
if l, ok := l.(Node); ok {
// Matching of pattern with concrete value
return matchNodeAST(m, l, r)
}
if l == nil || r == nil {
return nil, l == r
}
{
ln, ok1 := l.(ast.Node)
rn, ok2 := r.(ast.Node)
if ok1 && ok2 {
return matchAST(m, ln, rn)
}
}
{
obj, ok := l.(types.Object)
if ok {
switch r := r.(type) {
case *ast.Ident:
return obj, obj == m.TypesInfo.ObjectOf(r)
case *ast.SelectorExpr:
return obj, obj == m.TypesInfo.ObjectOf(r.Sel)
default:
return obj, false
}
}
}
{
ln, ok1 := l.([]ast.Expr)
rn, ok2 := r.([]ast.Expr)
if ok1 || ok2 {
if ok1 && !ok2 {
rn = []ast.Expr{r.(ast.Expr)}
} else if !ok1 && ok2 {
ln = []ast.Expr{l.(ast.Expr)}
}
if len(ln) != len(rn) {
return nil, false
}
for i, ll := range ln {
if _, ok := match(m, ll, rn[i]); !ok {
return nil, false
}
}
return r, true
}
}
{
ln, ok1 := l.([]ast.Stmt)
rn, ok2 := r.([]ast.Stmt)
if ok1 || ok2 {
if ok1 && !ok2 {
rn = []ast.Stmt{r.(ast.Stmt)}
} else if !ok1 && ok2 {
ln = []ast.Stmt{l.(ast.Stmt)}
}
if len(ln) != len(rn) {
return nil, false
}
for i, ll := range ln {
if _, ok := match(m, ll, rn[i]); !ok {
return nil, false
}
}
return r, true
}
}
{
ln, ok1 := l.([]*ast.Field)
rn, ok2 := r.([]*ast.Field)
if ok1 || ok2 {
if ok1 && !ok2 {
rn = []*ast.Field{r.(*ast.Field)}
} else if !ok1 && ok2 {
ln = []*ast.Field{l.(*ast.Field)}
}
if len(ln) != len(rn) {
return nil, false
}
for i, ll := range ln {
if _, ok := match(m, ll, rn[i]); !ok {
return nil, false
}
}
return r, true
}
}
panic(fmt.Sprintf("unsupported comparison: %T and %T", l, r))
}
// Match a Node with an AST node
func matchNodeAST(m *Matcher, a Node, b interface{}) (interface{}, bool) {
switch b := b.(type) {
case []ast.Stmt:
// 'a' is not a List or we'd be using its Match
// implementation.
if len(b) != 1 {
return nil, false
}
return match(m, a, b[0])
case []ast.Expr:
// 'a' is not a List or we'd be using its Match
// implementation.
if len(b) != 1 {
return nil, false
}
return match(m, a, b[0])
case ast.Node:
ra := reflect.ValueOf(a)
rb := reflect.ValueOf(b).Elem()
if ra.Type().Name() != rb.Type().Name() {
return nil, false
}
for i := 0; i < ra.NumField(); i++ {
af := ra.Field(i)
fieldName := ra.Type().Field(i).Name
bf := rb.FieldByName(fieldName)
if (bf == reflect.Value{}) {
panic(fmt.Sprintf("internal error: could not find field %s in type %t when comparing with %T", fieldName, b, a))
}
ai := af.Interface()
bi := bf.Interface()
if ai == nil {
return b, bi == nil
}
if _, ok := match(m, ai.(Node), bi); !ok {
return b, false
}
}
return b, true
case nil:
return nil, a == Nil{}
default:
panic(fmt.Sprintf("unhandled type %T", b))
}
}
// Match two AST nodes
func matchAST(m *Matcher, a, b ast.Node) (interface{}, bool) {
ra := reflect.ValueOf(a)
rb := reflect.ValueOf(b)
if ra.Type() != rb.Type() {
return nil, false
}
if ra.IsNil() || rb.IsNil() {
return rb, ra.IsNil() == rb.IsNil()
}
ra = ra.Elem()
rb = rb.Elem()
for i := 0; i < ra.NumField(); i++ {
af := ra.Field(i)
bf := rb.Field(i)
if af.Type() == rtTokPos || af.Type() == rtObject || af.Type() == rtCommentGroup {
continue
}
switch af.Kind() {
case reflect.Slice:
if af.Len() != bf.Len() {
return nil, false
}
for j := 0; j < af.Len(); j++ {
if _, ok := match(m, af.Index(j).Interface().(ast.Node), bf.Index(j).Interface().(ast.Node)); !ok {
return nil, false
}
}
case reflect.String:
if af.String() != bf.String() {
return nil, false
}
case reflect.Int:
if af.Int() != bf.Int() {
return nil, false
}
case reflect.Bool:
if af.Bool() != bf.Bool() {
return nil, false
}
case reflect.Ptr, reflect.Interface:
if _, ok := match(m, af.Interface(), bf.Interface()); !ok {
return nil, false
}
default:
panic(fmt.Sprintf("internal error: unhandled kind %s (%T)", af.Kind(), af.Interface()))
}
}
return b, true
}
func (b Binding) Match(m *Matcher, node interface{}) (interface{}, bool) {
if isNil(b.Node) {
v, ok := m.State[b.Name]
if ok {
// Recall value
return match(m, v, node)
}
// Matching anything
b.Node = Any{}
}
// Store value
if _, ok := m.State[b.Name]; ok {
panic(fmt.Sprintf("binding already created: %s", b.Name))
}
new, ret := match(m, b.Node, node)
if ret {
m.State[b.Name] = new
}
return new, ret
}
func (Any) Match(m *Matcher, node interface{}) (interface{}, bool) {
return node, true
}
func (l List) Match(m *Matcher, node interface{}) (interface{}, bool) {
v := reflect.ValueOf(node)
if v.Kind() == reflect.Slice {
if isNil(l.Head) {
return node, v.Len() == 0
}
if v.Len() == 0 {
return nil, false
}
// OPT(dh): don't check the entire tail if head didn't match
_, ok1 := match(m, l.Head, v.Index(0).Interface())
_, ok2 := match(m, l.Tail, v.Slice(1, v.Len()).Interface())
return node, ok1 && ok2
}
// Our empty list does not equal an untyped Go nil. This way, we can
// tell apart an if with no else and an if with an empty else.
return nil, false
}
func (s String) Match(m *Matcher, node interface{}) (interface{}, bool) {
switch o := node.(type) {
case token.Token:
if tok, ok := maybeToken(s); ok {
return match(m, tok, node)
}
return nil, false
case string:
return o, string(s) == o
default:
return nil, false
}
}
func (tok Token) Match(m *Matcher, node interface{}) (interface{}, bool) {
o, ok := node.(token.Token)
if !ok {
return nil, false
}
return o, token.Token(tok) == o
}
func (Nil) Match(m *Matcher, node interface{}) (interface{}, bool) {
return nil, isNil(node) || reflect.ValueOf(node).IsNil()
}
func (builtin Builtin) Match(m *Matcher, node interface{}) (interface{}, bool) {
r, ok := match(m, Ident(builtin), node)
if !ok {
return nil, false
}
ident := r.(*ast.Ident)
obj := m.TypesInfo.ObjectOf(ident)
if obj != types.Universe.Lookup(ident.Name) {
return nil, false
}
return ident, true
}
func (obj Object) Match(m *Matcher, node interface{}) (interface{}, bool) {
r, ok := match(m, Ident(obj), node)
if !ok {
return nil, false
}
ident := r.(*ast.Ident)
id := m.TypesInfo.ObjectOf(ident)
_, ok = match(m, obj.Name, ident.Name)
return id, ok
}
func (fn Function) Match(m *Matcher, node interface{}) (interface{}, bool) {
var name string
var obj types.Object
r, ok := match(m, Or{Nodes: []Node{Ident{Any{}}, SelectorExpr{Any{}, Any{}}}}, node)
if !ok {
return nil, false
}
switch r := r.(type) {
case *ast.Ident:
obj = m.TypesInfo.ObjectOf(r)
switch obj := obj.(type) {
case *types.Func:
// OPT(dh): optimize this similar to code.FuncName
name = obj.FullName()
case *types.Builtin:
name = obj.Name()
default:
return nil, false
}
case *ast.SelectorExpr:
var ok bool
obj, ok = m.TypesInfo.ObjectOf(r.Sel).(*types.Func)
if !ok {
return nil, false
}
// OPT(dh): optimize this similar to code.FuncName
name = obj.(*types.Func).FullName()
default:
panic("unreachable")
}
_, ok = match(m, fn.Name, name)
return obj, ok
}
func (or Or) Match(m *Matcher, node interface{}) (interface{}, bool) {
for _, opt := range or.Nodes {
mc := m.fork()
if ret, ok := match(mc, opt, node); ok {
m.merge(mc)
return ret, true
}
}
return nil, false
}
func (not Not) Match(m *Matcher, node interface{}) (interface{}, bool) {
_, ok := match(m, not.Node, node)
if ok {
return nil, false
}
return node, true
}
var (
// Types of fields in go/ast structs that we want to skip
rtTokPos = reflect.TypeOf(token.Pos(0))
rtObject = reflect.TypeOf((*ast.Object)(nil))
rtCommentGroup = reflect.TypeOf((*ast.CommentGroup)(nil))
)
var (
_ matcher = Binding{}
_ matcher = Any{}
_ matcher = List{}
_ matcher = String("")
_ matcher = Token(0)
_ matcher = Nil{}
_ matcher = Builtin{}
_ matcher = Object{}
_ matcher = Function{}
_ matcher = Or{}
_ matcher = Not{}
)
go-tools-2021.1.2/pattern/parser.go 0000664 0000000 0000000 00000033210 14143223131 0016773 0 ustar 00root root 0000000 0000000 package pattern
import (
"fmt"
"go/ast"
"go/token"
"reflect"
)
type Pattern struct {
Root Node
// Relevant contains instances of ast.Node that could potentially
// initiate a successful match of the pattern.
Relevant []reflect.Type
}
func MustParse(s string) Pattern {
p := &Parser{AllowTypeInfo: true}
pat, err := p.Parse(s)
if err != nil {
panic(err)
}
return pat
}
func roots(node Node) []reflect.Type {
switch node := node.(type) {
case Or:
var out []reflect.Type
for _, el := range node.Nodes {
out = append(out, roots(el)...)
}
return out
case Not:
return roots(node.Node)
case Binding:
return roots(node.Node)
case Nil, nil:
// this branch is reached via bindings
return allTypes
default:
Ts, ok := nodeToASTTypes[reflect.TypeOf(node)]
if !ok {
panic(fmt.Sprintf("internal error: unhandled type %T", node))
}
return Ts
}
}
var allTypes = []reflect.Type{
reflect.TypeOf((*ast.RangeStmt)(nil)),
reflect.TypeOf((*ast.AssignStmt)(nil)),
reflect.TypeOf((*ast.IndexExpr)(nil)),
reflect.TypeOf((*ast.Ident)(nil)),
reflect.TypeOf((*ast.ValueSpec)(nil)),
reflect.TypeOf((*ast.GenDecl)(nil)),
reflect.TypeOf((*ast.BinaryExpr)(nil)),
reflect.TypeOf((*ast.ForStmt)(nil)),
reflect.TypeOf((*ast.ArrayType)(nil)),
reflect.TypeOf((*ast.DeferStmt)(nil)),
reflect.TypeOf((*ast.MapType)(nil)),
reflect.TypeOf((*ast.ReturnStmt)(nil)),
reflect.TypeOf((*ast.SliceExpr)(nil)),
reflect.TypeOf((*ast.StarExpr)(nil)),
reflect.TypeOf((*ast.UnaryExpr)(nil)),
reflect.TypeOf((*ast.SendStmt)(nil)),
reflect.TypeOf((*ast.SelectStmt)(nil)),
reflect.TypeOf((*ast.ImportSpec)(nil)),
reflect.TypeOf((*ast.IfStmt)(nil)),
reflect.TypeOf((*ast.GoStmt)(nil)),
reflect.TypeOf((*ast.Field)(nil)),
reflect.TypeOf((*ast.SelectorExpr)(nil)),
reflect.TypeOf((*ast.StructType)(nil)),
reflect.TypeOf((*ast.KeyValueExpr)(nil)),
reflect.TypeOf((*ast.FuncType)(nil)),
reflect.TypeOf((*ast.FuncLit)(nil)),
reflect.TypeOf((*ast.FuncDecl)(nil)),
reflect.TypeOf((*ast.ChanType)(nil)),
reflect.TypeOf((*ast.CallExpr)(nil)),
reflect.TypeOf((*ast.CaseClause)(nil)),
reflect.TypeOf((*ast.CommClause)(nil)),
reflect.TypeOf((*ast.CompositeLit)(nil)),
reflect.TypeOf((*ast.EmptyStmt)(nil)),
reflect.TypeOf((*ast.SwitchStmt)(nil)),
reflect.TypeOf((*ast.TypeSwitchStmt)(nil)),
reflect.TypeOf((*ast.TypeAssertExpr)(nil)),
reflect.TypeOf((*ast.TypeSpec)(nil)),
reflect.TypeOf((*ast.InterfaceType)(nil)),
reflect.TypeOf((*ast.BranchStmt)(nil)),
reflect.TypeOf((*ast.IncDecStmt)(nil)),
reflect.TypeOf((*ast.BasicLit)(nil)),
}
var nodeToASTTypes = map[reflect.Type][]reflect.Type{
reflect.TypeOf(String("")): nil,
reflect.TypeOf(Token(0)): nil,
reflect.TypeOf(List{}): {reflect.TypeOf((*ast.BlockStmt)(nil)), reflect.TypeOf((*ast.FieldList)(nil))},
reflect.TypeOf(Builtin{}): {reflect.TypeOf((*ast.Ident)(nil))},
reflect.TypeOf(Object{}): {reflect.TypeOf((*ast.Ident)(nil))},
reflect.TypeOf(Function{}): {reflect.TypeOf((*ast.Ident)(nil)), reflect.TypeOf((*ast.SelectorExpr)(nil))},
reflect.TypeOf(Any{}): allTypes,
reflect.TypeOf(RangeStmt{}): {reflect.TypeOf((*ast.RangeStmt)(nil))},
reflect.TypeOf(AssignStmt{}): {reflect.TypeOf((*ast.AssignStmt)(nil))},
reflect.TypeOf(IndexExpr{}): {reflect.TypeOf((*ast.IndexExpr)(nil))},
reflect.TypeOf(Ident{}): {reflect.TypeOf((*ast.Ident)(nil))},
reflect.TypeOf(ValueSpec{}): {reflect.TypeOf((*ast.ValueSpec)(nil))},
reflect.TypeOf(GenDecl{}): {reflect.TypeOf((*ast.GenDecl)(nil))},
reflect.TypeOf(BinaryExpr{}): {reflect.TypeOf((*ast.BinaryExpr)(nil))},
reflect.TypeOf(ForStmt{}): {reflect.TypeOf((*ast.ForStmt)(nil))},
reflect.TypeOf(ArrayType{}): {reflect.TypeOf((*ast.ArrayType)(nil))},
reflect.TypeOf(DeferStmt{}): {reflect.TypeOf((*ast.DeferStmt)(nil))},
reflect.TypeOf(MapType{}): {reflect.TypeOf((*ast.MapType)(nil))},
reflect.TypeOf(ReturnStmt{}): {reflect.TypeOf((*ast.ReturnStmt)(nil))},
reflect.TypeOf(SliceExpr{}): {reflect.TypeOf((*ast.SliceExpr)(nil))},
reflect.TypeOf(StarExpr{}): {reflect.TypeOf((*ast.StarExpr)(nil))},
reflect.TypeOf(UnaryExpr{}): {reflect.TypeOf((*ast.UnaryExpr)(nil))},
reflect.TypeOf(SendStmt{}): {reflect.TypeOf((*ast.SendStmt)(nil))},
reflect.TypeOf(SelectStmt{}): {reflect.TypeOf((*ast.SelectStmt)(nil))},
reflect.TypeOf(ImportSpec{}): {reflect.TypeOf((*ast.ImportSpec)(nil))},
reflect.TypeOf(IfStmt{}): {reflect.TypeOf((*ast.IfStmt)(nil))},
reflect.TypeOf(GoStmt{}): {reflect.TypeOf((*ast.GoStmt)(nil))},
reflect.TypeOf(Field{}): {reflect.TypeOf((*ast.Field)(nil))},
reflect.TypeOf(SelectorExpr{}): {reflect.TypeOf((*ast.SelectorExpr)(nil))},
reflect.TypeOf(StructType{}): {reflect.TypeOf((*ast.StructType)(nil))},
reflect.TypeOf(KeyValueExpr{}): {reflect.TypeOf((*ast.KeyValueExpr)(nil))},
reflect.TypeOf(FuncType{}): {reflect.TypeOf((*ast.FuncType)(nil))},
reflect.TypeOf(FuncLit{}): {reflect.TypeOf((*ast.FuncLit)(nil))},
reflect.TypeOf(FuncDecl{}): {reflect.TypeOf((*ast.FuncDecl)(nil))},
reflect.TypeOf(ChanType{}): {reflect.TypeOf((*ast.ChanType)(nil))},
reflect.TypeOf(CallExpr{}): {reflect.TypeOf((*ast.CallExpr)(nil))},
reflect.TypeOf(CaseClause{}): {reflect.TypeOf((*ast.CaseClause)(nil))},
reflect.TypeOf(CommClause{}): {reflect.TypeOf((*ast.CommClause)(nil))},
reflect.TypeOf(CompositeLit{}): {reflect.TypeOf((*ast.CompositeLit)(nil))},
reflect.TypeOf(EmptyStmt{}): {reflect.TypeOf((*ast.EmptyStmt)(nil))},
reflect.TypeOf(SwitchStmt{}): {reflect.TypeOf((*ast.SwitchStmt)(nil))},
reflect.TypeOf(TypeSwitchStmt{}): {reflect.TypeOf((*ast.TypeSwitchStmt)(nil))},
reflect.TypeOf(TypeAssertExpr{}): {reflect.TypeOf((*ast.TypeAssertExpr)(nil))},
reflect.TypeOf(TypeSpec{}): {reflect.TypeOf((*ast.TypeSpec)(nil))},
reflect.TypeOf(InterfaceType{}): {reflect.TypeOf((*ast.InterfaceType)(nil))},
reflect.TypeOf(BranchStmt{}): {reflect.TypeOf((*ast.BranchStmt)(nil))},
reflect.TypeOf(IncDecStmt{}): {reflect.TypeOf((*ast.IncDecStmt)(nil))},
reflect.TypeOf(BasicLit{}): {reflect.TypeOf((*ast.BasicLit)(nil))},
}
var requiresTypeInfo = map[string]bool{
"Function": true,
"Builtin": true,
"Object": true,
}
type Parser struct {
// Allow nodes that rely on type information
AllowTypeInfo bool
lex *lexer
cur item
last *item
items chan item
}
func (p *Parser) Parse(s string) (Pattern, error) {
p.cur = item{}
p.last = nil
p.items = nil
fset := token.NewFileSet()
p.lex = &lexer{
f: fset.AddFile("
import "C"
import "unsafe"
func fnCgo(arg C.size_t) {
var ptr unsafe.Pointer
C.realloc(ptr, arg)
}
go-tools-2021.1.2/quickfix/testdata/src/CheckRedundantTypeInDeclaration/cgo.golden 0000664 0000000 0000000 00000000212 14143223131 0030035 0 ustar 00root root 0000000 0000000 package pkg
// #include
import "C"
import "unsafe"
func fnCgo(arg C.size_t) {
var ptr unsafe.Pointer
C.realloc(ptr, arg)
}
go-tools-2021.1.2/quickfix/testdata/src/CheckStringsReplaceAll/ 0000775 0000000 0000000 00000000000 14143223131 0024233 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/quickfix/testdata/src/CheckStringsReplaceAll/CheckStringsReplaceAll.go 0000664 0000000 0000000 00000001565 14143223131 0031105 0 ustar 00root root 0000000 0000000 package pkg
import (
"bytes"
"strings"
)
func fn() {
strings.Replace("", "", "", -1) // want `could use strings.ReplaceAll instead`
strings.Replace("", "", "", 0)
strings.Replace("", "", "", 1)
strings.SplitN("", "", -1) // want `could use strings.Split instead`
strings.SplitN("", "", 0)
strings.SplitN("", "", 1)
strings.SplitAfterN("", "", -1) // want `could use strings.SplitAfter instead`
strings.SplitAfterN("", "", 0)
strings.SplitAfterN("", "", 1)
bytes.Replace(nil, nil, nil, -1) // want `could use bytes.ReplaceAll instead`
bytes.Replace(nil, nil, nil, 0)
bytes.Replace(nil, nil, nil, 1)
bytes.SplitN(nil, nil, -1) // want `could use bytes.Split instead`
bytes.SplitN(nil, nil, 0)
bytes.SplitN(nil, nil, 1)
bytes.SplitAfterN(nil, nil, -1) // want `could use bytes.SplitAfter instead`
bytes.SplitAfterN(nil, nil, 0)
bytes.SplitAfterN(nil, nil, 1)
}
go-tools-2021.1.2/quickfix/testdata/src/CheckStringsReplaceAll/CheckStringsReplaceAll.go.golden 0000664 0000000 0000000 00000001537 14143223131 0032353 0 ustar 00root root 0000000 0000000 package pkg
import (
"bytes"
"strings"
)
func fn() {
strings.ReplaceAll("", "", "") // want `could use strings.ReplaceAll instead`
strings.Replace("", "", "", 0)
strings.Replace("", "", "", 1)
strings.Split("", "") // want `could use strings.Split instead`
strings.SplitN("", "", 0)
strings.SplitN("", "", 1)
strings.SplitAfter("", "") // want `could use strings.SplitAfter instead`
strings.SplitAfterN("", "", 0)
strings.SplitAfterN("", "", 1)
bytes.ReplaceAll(nil, nil, nil) // want `could use bytes.ReplaceAll instead`
bytes.Replace(nil, nil, nil, 0)
bytes.Replace(nil, nil, nil, 1)
bytes.Split(nil, nil) // want `could use bytes.Split instead`
bytes.SplitN(nil, nil, 0)
bytes.SplitN(nil, nil, 1)
bytes.SplitAfter(nil, nil) // want `could use bytes.SplitAfter instead`
bytes.SplitAfterN(nil, nil, 0)
bytes.SplitAfterN(nil, nil, 1)
}
go-tools-2021.1.2/quickfix/testdata/src/CheckTaglessSwitch/ 0000775 0000000 0000000 00000000000 14143223131 0023441 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/quickfix/testdata/src/CheckTaglessSwitch/CheckTaglessSwitch.go 0000664 0000000 0000000 00000001523 14143223131 0027513 0 ustar 00root root 0000000 0000000 package pkg
func foo() int { return 0 }
func fn1() {
var x, y int
var z map[string][]int
var a bool
switch { // want `could use tagged switch on x`
case x == 4: // comment
case x == 1 || x == 2, x == 3:
}
switch { // want `could use tagged switch on x`
case x == 1 || x == 2, x == 3:
case x == 4:
default:
}
switch { // want `could use tagged switch on z\[""\]\[0\]`
case z[""][0] == 1 || z[""][0] == 2:
}
switch { // want `could use tagged switch on a`
case a == (x == y) || a == (x != y):
}
switch {
case z[""][0] == 1 || z[""][1] == 2:
}
switch {
case x == 1 || x == 2, y == 3:
case x == 4:
default:
}
switch {
case x == 1 || x == 2, x == 3:
case y == 4:
}
switch {
case x == 1 || x == 2, x == foo():
case x == 4:
default:
}
switch {
}
switch {
default:
}
switch {
case x == 1 && x == 2:
}
}
go-tools-2021.1.2/quickfix/testdata/src/CheckTaglessSwitch/CheckTaglessSwitch.go.golden 0000664 0000000 0000000 00000001414 14143223131 0030761 0 ustar 00root root 0000000 0000000 package pkg
func foo() int { return 0 }
func fn1() {
var x, y int
var z map[string][]int
var a bool
switch x { // want `could use tagged switch on x`
case 4: // comment
case 1, 2, 3:
}
switch x { // want `could use tagged switch on x`
case 1, 2, 3:
case 4:
default:
}
switch z[""][0] { // want `could use tagged switch on z\[""\]\[0\]`
case 1, 2:
}
switch a { // want `could use tagged switch on a`
case x == y, x != y:
}
switch {
case z[""][0] == 1 || z[""][1] == 2:
}
switch {
case x == 1 || x == 2, y == 3:
case x == 4:
default:
}
switch {
case x == 1 || x == 2, x == 3:
case y == 4:
}
switch {
case x == 1 || x == 2, x == foo():
case x == 4:
default:
}
switch {
}
switch {
default:
}
switch {
case x == 1 && x == 2:
}
}
go-tools-2021.1.2/quickfix/testdata/src/CheckTimeEquality/ 0000775 0000000 0000000 00000000000 14143223131 0023271 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/quickfix/testdata/src/CheckTimeEquality/CheckTimeEquality.go 0000664 0000000 0000000 00000000462 14143223131 0027174 0 ustar 00root root 0000000 0000000 package pkg
import "time"
func foo() time.Time { return time.Time{} }
func bar() time.Time { return time.Time{} }
func fn() {
var t1, t2 time.Time
if t1 == t2 { // want `probably want to use time.Time.Equal instead`
}
if foo() == bar() { // want `probably want to use time.Time.Equal instead`
}
}
go-tools-2021.1.2/quickfix/testdata/src/CheckTimeEquality/CheckTimeEquality.go.golden 0000664 0000000 0000000 00000000472 14143223131 0030444 0 ustar 00root root 0000000 0000000 package pkg
import "time"
func foo() time.Time { return time.Time{} }
func bar() time.Time { return time.Time{} }
func fn() {
var t1, t2 time.Time
if t1.Equal(t2) { // want `probably want to use time.Time.Equal instead`
}
if foo().Equal(bar()) { // want `probably want to use time.Time.Equal instead`
}
}
go-tools-2021.1.2/sarif/ 0000775 0000000 0000000 00000000000 14143223131 0014600 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/sarif/sarif.go 0000664 0000000 0000000 00000010316 14143223131 0016234 0 ustar 00root root 0000000 0000000 package sarif
const Version = "2.1.0"
const Schema = "https://schemastore.azurewebsites.net/schemas/json/sarif-2.1.0-rtm.4.json"
type Log struct {
Version string `json:"version"`
Schema string `json:"$schema"`
Runs []Run `json:"runs"`
}
type Run struct {
Tool Tool `json:"tool"`
Results []Result `json:"results,omitempty"`
Invocations []Invocation `json:"invocations,omitempty"`
Artifacts []Artifact `json:"artifacts,omitempty"`
}
type Artifact struct {
Location ArtifactLocation `json:"location"`
Length int `json:"length"`
SourceLanguage string `json:"sourceLanguage"`
Roles []string `json:"roles"`
Encoding string `json:"encoding"`
}
const (
AnalysisTarget = "analysisTarget"
UTF8 = "UTF-8"
Fail = "fail"
Warning = "warning"
Error = "error"
Note = "note"
None = "none"
)
type Hash struct {
Sha256 string `json:"sha-256"`
}
type Tool struct {
Driver ToolComponent `json:"driver"`
}
type Invocation struct {
CommandLine string `json:"commandLine"`
Arguments []string `json:"arguments,omitempty"`
WorkingDirectory ArtifactLocation `json:"workingDirectory"`
ExecutionSuccessful bool `json:"executionSuccessful"`
}
type ToolComponent struct {
Name string `json:"name"`
Version string `json:"version"`
SemanticVersion string `json:"semanticVersion"`
InformationURI string `json:"informationUri"`
Rules []ReportingDescriptor `json:"rules,omitempty"`
}
type ReportingDescriptor struct {
ID string `json:"id"`
ShortDescription Message `json:"shortDescription"`
// FullDescription Message `json:"fullDescription"`
Help Message `json:"help"`
HelpURI string `json:"helpUri,omitempty"`
}
type ReportingConfiguration struct {
Enabled bool `json:"bool"`
Level string `json:"level"`
Parameters map[string]interface{} `json:"parameters"`
}
type Result struct {
RuleID string `json:"ruleId"`
// RuleIndex int `json:"ruleIndex"`
Kind string `json:"kind"`
Level string `json:"level"`
Message Message `json:"message"`
Locations []Location `json:"locations,omitempty"`
RelatedLocations []Location `json:"relatedLocations,omitempty"`
Fixes []Fix `json:"fixes,omitempty"`
Suppressions []Suppression `json:"suppressions"`
}
type Suppression struct {
Kind string `json:"kind"`
Justification string `json:"justification"`
}
type Fix struct {
Description Message `json:"description"`
ArtifactChanges []ArtifactChange `json:"artifactChanges"`
}
type ArtifactChange struct {
ArtifactLocation ArtifactLocation `json:"artifactLocation"`
Replacements []Replacement `json:"replacements"`
}
type Replacement struct {
DeletedRegion Region `json:"deletedRegion"`
InsertedContent ArtifactContent `json:"insertedContent"`
}
type ArtifactContent struct {
Text string `json:"text"`
}
type Message struct {
Text string `json:"text,omitempty"`
Markdown string `json:"markdown,omitempty"`
}
type Location struct {
ID int `json:"id,omitempty"`
Message *Message `json:"message,omitempty"`
PhysicalLocation PhysicalLocation `json:"physicalLocation"`
}
type PhysicalLocation struct {
ArtifactLocation ArtifactLocation `json:"artifactLocation"`
Region Region `json:"region"`
}
type ArtifactLocation struct {
URI string `json:"uri,omitempty"`
Index int `json:"index,omitempty"`
}
type Region struct {
StartLine int `json:"startLine"`
StartColumn int `json:"startColumn"`
EndLine int `json:"endLine,omitempty"`
EndColumn int `json:"endColumn,omitempty"`
}
// XXX URIs should use actual URI encoding, not just be strings. also, do we have to use the 'file' protocol for relative URIs?
// XXX columns have to be in one of UTF-16 code units or unicode code points⦠meanwhile, we track bytes
// XXX columns in Region are 1-based, but we're probably passing in 0-based offsets
go-tools-2021.1.2/simple/ 0000775 0000000 0000000 00000000000 14143223131 0014765 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/analysis.go 0000664 0000000 0000000 00000010475 14143223131 0017146 0 ustar 00root root 0000000 0000000 package simple
import (
"golang.org/x/tools/go/analysis"
"golang.org/x/tools/go/analysis/passes/inspect"
"honnef.co/go/tools/analysis/facts"
"honnef.co/go/tools/analysis/lint"
"honnef.co/go/tools/internal/passes/buildir"
)
var Analyzers = lint.InitializeAnalyzers(Docs, map[string]*analysis.Analyzer{
"S1000": {
Run: CheckSingleCaseSelect,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1001": {
Run: CheckLoopCopy,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1002": {
Run: CheckIfBoolCmp,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1003": {
Run: CheckStringsContains,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1004": {
Run: CheckBytesCompare,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1005": {
Run: CheckUnnecessaryBlank,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1006": {
Run: CheckForTrue,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1007": {
Run: CheckRegexpRaw,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1008": {
Run: CheckIfReturn,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1009": {
Run: CheckRedundantNilCheckWithLen,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1010": {
Run: CheckSlicing,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1011": {
Run: CheckLoopAppend,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1012": {
Run: CheckTimeSince,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1016": {
Run: CheckSimplerStructConversion,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1017": {
Run: CheckTrim,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1018": {
Run: CheckLoopSlide,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1019": {
Run: CheckMakeLenCap,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1020": {
Run: CheckAssertNotNil,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1021": {
Run: CheckDeclareAssign,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1023": {
Run: CheckRedundantBreak,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1024": {
Run: CheckTimeUntil,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1025": {
Run: CheckRedundantSprintf,
Requires: []*analysis.Analyzer{buildir.Analyzer, inspect.Analyzer, facts.Generated},
},
"S1028": {
Run: CheckErrorsNewSprintf,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1029": {
Run: CheckRangeStringRunes,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"S1030": {
Run: CheckBytesBufferConversions,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1031": {
Run: CheckNilCheckAroundRange,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1032": {
Run: CheckSortHelpers,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1033": {
Run: CheckGuardedDelete,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1034": {
Run: CheckSimplifyTypeSwitch,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1035": {
Run: CheckRedundantCanonicalHeaderKey,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1036": {
Run: CheckUnnecessaryGuard,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"S1037": {
Run: CheckElaborateSleep,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1038": {
Run: CheckPrintSprintf,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1039": {
Run: CheckSprintLiteral,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
"S1040": {
Run: CheckSameTypeTypeAssertion,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
},
})
go-tools-2021.1.2/simple/doc.go 0000664 0000000 0000000 00000025361 14143223131 0016070 0 ustar 00root root 0000000 0000000 package simple
import "honnef.co/go/tools/analysis/lint"
var Docs = lint.Markdownify(map[string]*lint.Documentation{
"S1000": {
Title: `Use plain channel send or receive instead of single-case select`,
Text: `Select statements with a single case can be replaced with a simple
send or receive.
Before:
select {
case x := <-ch:
fmt.Println(x)
}
After:
x := <-ch
fmt.Println(x)`,
Since: "2017.1",
},
"S1001": {
Title: `Replace for loop with call to copy`,
Text: `Use \'copy()\' for copying elements from one slice to another.
Before:
for i, x := range src {
dst[i] = x
}
After:
copy(dst, src)`,
Since: "2017.1",
},
"S1002": {
Title: `Omit comparison with boolean constant`,
Text: `Before:
if x == true {}
After:
if x {}`,
Since: "2017.1",
},
"S1003": {
Title: "Replace call to `strings.Index` with `strings.Contains`",
Text: `Before:
if strings.Index(x, y) != -1 {}
After:
if strings.Contains(x, y) {}`,
Since: "2017.1",
},
"S1004": {
Title: "Replace call to `bytes.Compare` with `bytes.Equal`",
Text: `Before:
if bytes.Compare(x, y) == 0 {}
After:
if bytes.Equal(x, y) {}`,
Since: "2017.1",
},
"S1005": {
Title: `Drop unnecessary use of the blank identifier`,
Text: `In many cases, assigning to the blank identifier is unnecessary.
Before:
for _ = range s {}
x, _ = someMap[key]
_ = <-ch
After:
for range s{}
x = someMap[key]
<-ch`,
Since: "2017.1",
},
"S1006": {
Title: "Use `for { ... }` for infinite loops",
Text: `For infinite loops, using \'for { ... }\' is the most idiomatic choice.`,
Since: "2017.1",
},
"S1007": {
Title: `Simplify regular expression by using raw string literal`,
Text: `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` + "`" + `)`,
Since: "2017.1",
},
"S1008": {
Title: `Simplify returning boolean expression`,
Text: `Before:
if {
return true
}
return false
After:
return `,
Since: "2017.1",
},
"S1009": {
Title: `Omit redundant nil check on slices`,
Text: `The \'len\' function is defined for all slices, even nil ones, which have
a length of zero. It is not necessary to check if a slice is not nil
before checking that its length is not zero.
Before:
if x != nil && len(x) != 0 {}
After:
if len(x) != 0 {}`,
Since: "2017.1",
},
"S1010": {
Title: `Omit default slice index`,
Text: `When slicing, the second index defaults to the length of the value,
making \'s[n:len(s)]\' and \'s[n:]\' equivalent.`,
Since: "2017.1",
},
"S1011": {
Title: "Use a single `append` to concatenate two slices",
Text: `Before:
for _, e := range y {
x = append(x, e)
}
After:
x = append(x, y...)`,
Since: "2017.1",
},
"S1012": {
Title: "Replace `time.Now().Sub(x)` with `time.Since(x)`",
Text: `The \'time.Since\' helper has the same effect as using \'time.Now().Sub(x)\'
but is easier to read.
Before:
time.Now().Sub(x)
After:
time.Since(x)`,
Since: "2017.1",
},
"S1016": {
Title: `Use a type conversion instead of manually copying struct fields`,
Text: `Two struct types with identical fields can be converted between each
other. In older versions of Go, the fields had to have identical
struct tags. Since Go 1.8, however, struct tags are ignored during
conversions. It is thus not necessary to manually copy every field
individually.
Before:
var x T1
y := T2{
Field1: x.Field1,
Field2: x.Field2,
}
After:
var x T1
y := T2(x)`,
Since: "2017.1",
},
"S1017": {
Title: "Replace manual trimming with `strings.TrimPrefix`",
Text: `Instead of using \'strings.HasPrefix\' and manual slicing, use the
\'strings.TrimPrefix\' function. If the string doesn't start with the
prefix, the original string will be returned. Using \'strings.TrimPrefix\'
reduces complexity, and avoids common bugs, such as off-by-one
mistakes.
Before:
if strings.HasPrefix(str, prefix) {
str = str[len(prefix):]
}
After:
str = strings.TrimPrefix(str, prefix)`,
Since: "2017.1",
},
"S1018": {
Title: "Use `copy` for sliding elements",
Text: `\'copy()\' permits using the same source and destination slice, even with
overlapping ranges. This makes it ideal for sliding elements in a
slice.
Before:
for i := 0; i < n; i++ {
bs[i] = bs[offset+i]
}
After:
copy(bs[:n], bs[offset:])`,
Since: "2017.1",
},
"S1019": {
Title: "Simplify `make` call by omitting redundant arguments",
Text: `The \'make\' function has default values for the length and capacity
arguments. For channels, the length defaults to zero, and for slices, the capacity defaults to the length.`,
Since: "2017.1",
},
"S1020": {
Title: `Omit redundant nil check in type assertion`,
Text: `Before:
if _, ok := i.(T); ok && i != nil {}
After:
if _, ok := i.(T); ok {}`,
Since: "2017.1",
},
"S1021": {
Title: `Merge variable declaration and assignment`,
Text: `Before:
var x uint
x = 1
After:
var x uint = 1`,
Since: "2017.1",
},
"S1023": {
Title: `Omit redundant control flow`,
Text: `Functions that have no return value do not need a return statement as
the final statement of the function.
Switches in Go do not have automatic fallthrough, unlike languages
like C. It is not necessary to have a break statement as the final
statement in a case block.`,
Since: "2017.1",
},
"S1024": {
Title: "Replace `x.Sub(time.Now())` with `time.Until(x)`",
Text: `The \'time.Until\' helper has the same effect as using \'x.Sub(time.Now())\'
but is easier to read.
Before:
x.Sub(time.Now())
After:
time.Until(x)`,
Since: "2017.1",
},
"S1025": {
Title: "Don't use `fmt.Sprintf(\"%s\", x)` unnecessarily",
Text: `In many instances, there are easier and more efficient ways of getting
a value's string representation. Whenever a value's underlying type is
a string already, or the type has a String method, they should be used
directly.
Given the following shared definitions
type T1 string
type T2 int
func (T2) String() string { return "Hello, world" }
var x string
var y T1
var z T2
we can simplify the following
fmt.Sprintf("%s", x)
fmt.Sprintf("%s", y)
fmt.Sprintf("%s", z)
to
x
string(y)
z.String()`,
Since: "2017.1",
},
"S1028": {
Title: "Simplify error construction with `fmt.Errorf`",
Text: `Before:
errors.New(fmt.Sprintf(...))
After:
fmt.Errorf(...)`,
Since: "2017.1",
},
"S1029": {
Title: `Range over the string directly`,
Text: `Ranging over a string will yield byte offsets and runes. If the offset
isn't used, this is functionally equivalent to converting the string
to a slice of runes and ranging over that. Ranging directly over the
string will be more performant, however, as it avoids allocating a new
slice, the size of which depends on the length of the string.
Before:
for _, r := range []rune(s) {}
After:
for _, r := range s {}`,
Since: "2017.1",
},
"S1030": {
Title: "Use `bytes.Buffer.String` or `bytes.Buffer.Bytes`",
Text: `\'bytes.Buffer\' has both a \'String\' and a \'Bytes\' method. It is almost never
necessary to use \'string(buf.Bytes())\' or \'[]byte(buf.String())\' β simply
use the other method.
The only exception to this are map lookups. Due to a compiler optimization,
\'m[string(buf.Bytes())]\' is more efficient than \'m[buf.String()]\'.
`,
Since: "2017.1",
},
"S1031": {
Title: `Omit redundant nil check around loop`,
Text: `You can use range on nil slices and maps, the loop will simply never
execute. This makes an additional nil check around the loop
unnecessary.
Before:
if s != nil {
for _, x := range s {
...
}
}
After:
for _, x := range s {
...
}`,
Since: "2017.1",
},
"S1032": {
Title: "Use `sort.Ints(x)`, `sort.Float64s(x)`, and `sort.Strings(x)`",
Text: `The \'sort.Ints\', \'sort.Float64s\' and \'sort.Strings\' functions are easier to
read than \'sort.Sort(sort.IntSlice(x))\', \'sort.Sort(sort.Float64Slice(x))\'
and \'sort.Sort(sort.StringSlice(x))\'.
Before:
sort.Sort(sort.StringSlice(x))
After:
sort.Strings(x)`,
Since: "2019.1",
},
"S1033": {
Title: "Unnecessary guard around call to `delete`",
Text: `Calling \'delete\' on a nil map is a no-op.`,
Since: "2019.2",
},
"S1034": {
Title: `Use result of type assertion to simplify cases`,
Since: "2019.2",
},
"S1035": {
Title: "Redundant call to `net/http.CanonicalHeaderKey` in method call on `net/http.Header`",
Text: `The methods on \'net/http.Header\', namely \'Add\', \'Del\', \'Get\' and \'Set\', already
canonicalize the given header name.`,
Since: "2020.1",
},
"S1036": {
Title: `Unnecessary guard around map access`,
Text: `When accessing a map key that doesn't exist yet, one
receives a zero value. Often, the zero value is a suitable value, for example when using append or doing integer math.
The following
if _, ok := m["foo"]; ok {
m["foo"] = append(m["foo"], "bar")
} else {
m["foo"] = []string{"bar"}
}
can be simplified to
m["foo"] = append(m["foo"], "bar")
and
if _, ok := m2["k"]; ok {
m2["k"] += 4
} else {
m2["k"] = 4
}
can be simplified to
m["k"] += 4
`,
Since: "2020.1",
},
"S1037": {
Title: `Elaborate way of sleeping`,
Text: `Using a select statement with a single case receiving
from the result of \'time.After\' is a very elaborate way of sleeping that
can much simpler be expressed with a simple call to time.Sleep.`,
Since: "2020.1",
},
"S1038": {
Title: "Unnecessarily complex way of printing formatted string",
Text: `Instead of using \'fmt.Print(fmt.Sprintf(...))\', one can use \'fmt.Printf(...)\'.`,
Since: "2020.1",
},
"S1039": {
Title: "Unnecessary use of `fmt.Sprint`",
Text: `Calling \'fmt.Sprint\' with a single string argument is unnecessary and identical to using the string directly.`,
Since: "2020.1",
},
"S1040": {
Title: "Type assertion to current type",
Text: `The type assertion \'x.(SomeInterface)\', when \'x\' already has type
\'SomeInterface\', can only fail if \'x\' is nil. Usually, this is
left-over code from when \'x\' had a different type and you can safely
delete the type assertion. If you want to check that \'x\' is not nil,
consider being explicit and using an actual \'if x == nil\' comparison
instead of relying on the type assertion panicking.`,
Since: "2021.1",
},
})
go-tools-2021.1.2/simple/lint.go 0000664 0000000 0000000 00000153667 14143223131 0016304 0 ustar 00root root 0000000 0000000 // Package simple contains a linter for Go source code.
package simple
import (
"fmt"
"go/ast"
"go/constant"
"go/token"
"go/types"
"path/filepath"
"reflect"
"sort"
"strings"
"honnef.co/go/tools/analysis/code"
"honnef.co/go/tools/analysis/edit"
"honnef.co/go/tools/analysis/lint"
"honnef.co/go/tools/analysis/report"
"honnef.co/go/tools/go/ast/astutil"
"honnef.co/go/tools/go/types/typeutil"
"honnef.co/go/tools/internal/passes/buildir"
"honnef.co/go/tools/internal/sharedcheck"
"honnef.co/go/tools/knowledge"
"honnef.co/go/tools/pattern"
"golang.org/x/tools/go/analysis"
)
var (
checkSingleCaseSelectQ1 = pattern.MustParse(`
(ForStmt
nil nil nil
select@(SelectStmt
(CommClause
(Or
(UnaryExpr "<-" _)
(AssignStmt _ _ (UnaryExpr "<-" _)))
_)))`)
checkSingleCaseSelectQ2 = pattern.MustParse(`(SelectStmt (CommClause _ _))`)
)
func CheckSingleCaseSelect(pass *analysis.Pass) (interface{}, error) {
seen := map[ast.Node]struct{}{}
fn := func(node ast.Node) {
if m, ok := code.Match(pass, checkSingleCaseSelectQ1, node); ok {
seen[m.State["select"].(ast.Node)] = struct{}{}
report.Report(pass, node, "should use for range instead of for { select {} }", report.FilterGenerated())
} else if _, ok := code.Match(pass, checkSingleCaseSelectQ2, node); ok {
if _, ok := seen[node]; !ok {
report.Report(pass, node, "should use a simple channel send/receive instead of select with a single case",
report.ShortRange(),
report.FilterGenerated())
}
}
}
code.Preorder(pass, fn, (*ast.ForStmt)(nil), (*ast.SelectStmt)(nil))
return nil, nil
}
var (
checkLoopCopyQ = pattern.MustParse(`
(Or
(RangeStmt
key value ":=" src@(Ident _)
[(AssignStmt
(IndexExpr dst@(Ident _) key)
"="
value)])
(RangeStmt
key nil ":=" src@(Ident _)
[(AssignStmt
(IndexExpr dst@(Ident _) key)
"="
(IndexExpr src key))]))`)
checkLoopCopyR = pattern.MustParse(`(CallExpr (Ident "copy") [dst src])`)
)
func CheckLoopCopy(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
m, edits, ok := code.MatchAndEdit(pass, checkLoopCopyQ, checkLoopCopyR, node)
if !ok {
return
}
t1 := pass.TypesInfo.TypeOf(m.State["src"].(*ast.Ident))
t2 := pass.TypesInfo.TypeOf(m.State["dst"].(*ast.Ident))
if _, ok := t1.Underlying().(*types.Slice); !ok {
return
}
if !types.Identical(t1, t2) {
return
}
tv, err := types.Eval(pass.Fset, pass.Pkg, node.Pos(), "copy")
if err == nil && tv.IsBuiltin() {
report.Report(pass, node,
"should use copy() instead of a loop",
report.ShortRange(),
report.FilterGenerated(),
report.Fixes(edit.Fix("replace loop with call to copy()", edits...)))
} else {
report.Report(pass, node, "should use copy() instead of a loop", report.FilterGenerated())
}
}
code.Preorder(pass, fn, (*ast.RangeStmt)(nil))
return nil, nil
}
func CheckIfBoolCmp(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
if code.IsInTest(pass, node) {
return
}
expr := node.(*ast.BinaryExpr)
if expr.Op != token.EQL && expr.Op != token.NEQ {
return
}
x := code.IsBoolConst(pass, expr.X)
y := code.IsBoolConst(pass, expr.Y)
if !x && !y {
return
}
var other ast.Expr
var val bool
if x {
val = code.BoolConst(pass, expr.X)
other = expr.Y
} else {
val = code.BoolConst(pass, expr.Y)
other = expr.X
}
basic, ok := pass.TypesInfo.TypeOf(other).Underlying().(*types.Basic)
if !ok || basic.Kind() != types.Bool {
return
}
op := ""
if (expr.Op == token.EQL && !val) || (expr.Op == token.NEQ && val) {
op = "!"
}
r := op + report.Render(pass, other)
l1 := len(r)
r = strings.TrimLeft(r, "!")
if (l1-len(r))%2 == 1 {
r = "!" + r
}
report.Report(pass, expr, fmt.Sprintf("should omit comparison to bool constant, can be simplified to %s", r),
report.FilterGenerated(),
report.Fixes(edit.Fix("simplify bool comparison", edit.ReplaceWithString(pass.Fset, expr, r))))
}
code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
return nil, nil
}
var (
checkBytesBufferConversionsQ = pattern.MustParse(`(CallExpr _ [(CallExpr sel@(SelectorExpr recv _) [])])`)
checkBytesBufferConversionsRs = pattern.MustParse(`(CallExpr (SelectorExpr recv (Ident "String")) [])`)
checkBytesBufferConversionsRb = pattern.MustParse(`(CallExpr (SelectorExpr recv (Ident "Bytes")) [])`)
)
func CheckBytesBufferConversions(pass *analysis.Pass) (interface{}, error) {
if pass.Pkg.Path() == "bytes" || pass.Pkg.Path() == "bytes_test" {
// The bytes package can use itself however it wants
return nil, nil
}
fn := func(node ast.Node, stack []ast.Node) {
m, ok := code.Match(pass, checkBytesBufferConversionsQ, node)
if !ok {
return
}
call := node.(*ast.CallExpr)
sel := m.State["sel"].(*ast.SelectorExpr)
typ := pass.TypesInfo.TypeOf(call.Fun)
if typ == types.Universe.Lookup("string").Type() && code.IsCallTo(pass, call.Args[0], "(*bytes.Buffer).Bytes") {
if _, ok := stack[len(stack)-2].(*ast.IndexExpr); ok {
// Don't flag m[string(buf.Bytes())] β thanks to a
// compiler optimization, this is actually faster than
// m[buf.String()]
return
}
report.Report(pass, call, fmt.Sprintf("should use %v.String() instead of %v", report.Render(pass, sel.X), report.Render(pass, call)),
report.FilterGenerated(),
report.Fixes(edit.Fix("simplify conversion", edit.ReplaceWithPattern(pass, checkBytesBufferConversionsRs, m.State, node))))
} else if typ, ok := typ.(*types.Slice); ok && typ.Elem() == types.Universe.Lookup("byte").Type() && code.IsCallTo(pass, call.Args[0], "(*bytes.Buffer).String") {
report.Report(pass, call, fmt.Sprintf("should use %v.Bytes() instead of %v", report.Render(pass, sel.X), report.Render(pass, call)),
report.FilterGenerated(),
report.Fixes(edit.Fix("simplify conversion", edit.ReplaceWithPattern(pass, checkBytesBufferConversionsRb, m.State, node))))
}
}
code.PreorderStack(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
func CheckStringsContains(pass *analysis.Pass) (interface{}, error) {
// map of value to token to bool value
allowed := map[int64]map[token.Token]bool{
-1: {token.GTR: true, token.NEQ: true, token.EQL: false},
0: {token.GEQ: true, token.LSS: false},
}
fn := func(node ast.Node) {
expr := node.(*ast.BinaryExpr)
switch expr.Op {
case token.GEQ, token.GTR, token.NEQ, token.LSS, token.EQL:
default:
return
}
value, ok := code.ExprToInt(pass, expr.Y)
if !ok {
return
}
allowedOps, ok := allowed[value]
if !ok {
return
}
b, ok := allowedOps[expr.Op]
if !ok {
return
}
call, ok := expr.X.(*ast.CallExpr)
if !ok {
return
}
sel, ok := call.Fun.(*ast.SelectorExpr)
if !ok {
return
}
pkgIdent, ok := sel.X.(*ast.Ident)
if !ok {
return
}
funIdent := sel.Sel
if pkgIdent.Name != "strings" && pkgIdent.Name != "bytes" {
return
}
var r ast.Expr
switch funIdent.Name {
case "IndexRune":
r = &ast.SelectorExpr{
X: pkgIdent,
Sel: &ast.Ident{Name: "ContainsRune"},
}
case "IndexAny":
r = &ast.SelectorExpr{
X: pkgIdent,
Sel: &ast.Ident{Name: "ContainsAny"},
}
case "Index":
r = &ast.SelectorExpr{
X: pkgIdent,
Sel: &ast.Ident{Name: "Contains"},
}
default:
return
}
r = &ast.CallExpr{
Fun: r,
Args: call.Args,
}
if !b {
r = &ast.UnaryExpr{
Op: token.NOT,
X: r,
}
}
report.Report(pass, node, fmt.Sprintf("should use %s instead", report.Render(pass, r)),
report.FilterGenerated(),
report.Fixes(edit.Fix(fmt.Sprintf("simplify use of %s", report.Render(pass, call.Fun)), edit.ReplaceWithNode(pass.Fset, node, r))))
}
code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
return nil, nil
}
var (
checkBytesCompareQ = pattern.MustParse(`(BinaryExpr (CallExpr (Function "bytes.Compare") args) op@(Or "==" "!=") (BasicLit "INT" "0"))`)
checkBytesCompareRe = pattern.MustParse(`(CallExpr (SelectorExpr (Ident "bytes") (Ident "Equal")) args)`)
checkBytesCompareRn = pattern.MustParse(`(UnaryExpr "!" (CallExpr (SelectorExpr (Ident "bytes") (Ident "Equal")) args))`)
)
func CheckBytesCompare(pass *analysis.Pass) (interface{}, error) {
if pass.Pkg.Path() == "bytes" || pass.Pkg.Path() == "bytes_test" {
// the bytes package is free to use bytes.Compare as it sees fit
return nil, nil
}
fn := func(node ast.Node) {
m, ok := code.Match(pass, checkBytesCompareQ, node)
if !ok {
return
}
args := report.RenderArgs(pass, m.State["args"].([]ast.Expr))
prefix := ""
if m.State["op"].(token.Token) == token.NEQ {
prefix = "!"
}
var fix analysis.SuggestedFix
switch tok := m.State["op"].(token.Token); tok {
case token.EQL:
fix = edit.Fix("simplify use of bytes.Compare", edit.ReplaceWithPattern(pass, checkBytesCompareRe, m.State, node))
case token.NEQ:
fix = edit.Fix("simplify use of bytes.Compare", edit.ReplaceWithPattern(pass, checkBytesCompareRn, m.State, node))
default:
panic(fmt.Sprintf("unexpected token %v", tok))
}
report.Report(pass, node, fmt.Sprintf("should use %sbytes.Equal(%s) instead", prefix, args), report.FilterGenerated(), report.Fixes(fix))
}
code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
return nil, nil
}
func CheckForTrue(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
loop := node.(*ast.ForStmt)
if loop.Init != nil || loop.Post != nil {
return
}
if !code.IsBoolConst(pass, loop.Cond) || !code.BoolConst(pass, loop.Cond) {
return
}
report.Report(pass, loop, "should use for {} instead of for true {}",
report.ShortRange(),
report.FilterGenerated())
}
code.Preorder(pass, fn, (*ast.ForStmt)(nil))
return nil, nil
}
func CheckRegexpRaw(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
call := node.(*ast.CallExpr)
if !code.IsCallToAny(pass, call, "regexp.MustCompile", "regexp.Compile") {
return
}
sel, ok := call.Fun.(*ast.SelectorExpr)
if !ok {
return
}
lit, ok := call.Args[knowledge.Arg("regexp.Compile.expr")].(*ast.BasicLit)
if !ok {
// TODO(dominikh): support string concat, maybe support constants
return
}
if lit.Kind != token.STRING {
// invalid function call
return
}
if lit.Value[0] != '"' {
// already a raw string
return
}
val := lit.Value
if !strings.Contains(val, `\\`) {
return
}
if strings.Contains(val, "`") {
return
}
bs := false
for _, c := range val {
if !bs && c == '\\' {
bs = true
continue
}
if bs && c == '\\' {
bs = false
continue
}
if bs {
// backslash followed by non-backslash -> escape sequence
return
}
}
report.Report(pass, call, fmt.Sprintf("should use raw string (`...`) with regexp.%s to avoid having to escape twice", sel.Sel.Name), report.FilterGenerated())
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
var (
checkIfReturnQIf = pattern.MustParse(`(IfStmt nil cond [(ReturnStmt [ret@(Ident _)])] nil)`)
checkIfReturnQRet = pattern.MustParse(`(ReturnStmt [ret@(Ident _)])`)
)
func CheckIfReturn(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
block := node.(*ast.BlockStmt)
l := len(block.List)
if l < 2 {
return
}
n1, n2 := block.List[l-2], block.List[l-1]
if len(block.List) >= 3 {
if _, ok := block.List[l-3].(*ast.IfStmt); ok {
// Do not flag a series of if statements
return
}
}
m1, ok := code.Match(pass, checkIfReturnQIf, n1)
if !ok {
return
}
m2, ok := code.Match(pass, checkIfReturnQRet, n2)
if !ok {
return
}
if op, ok := m1.State["cond"].(*ast.BinaryExpr); ok {
switch op.Op {
case token.EQL, token.LSS, token.GTR, token.NEQ, token.LEQ, token.GEQ:
default:
return
}
}
ret1 := m1.State["ret"].(*ast.Ident)
if !code.IsBoolConst(pass, ret1) {
return
}
ret2 := m2.State["ret"].(*ast.Ident)
if !code.IsBoolConst(pass, ret2) {
return
}
if ret1.Name == ret2.Name {
// we want the function to return true and false, not the
// same value both times.
return
}
cond := m1.State["cond"].(ast.Expr)
origCond := cond
if ret1.Name == "false" {
cond = negate(cond)
}
report.Report(pass, n1,
fmt.Sprintf("should use 'return %s' instead of 'if %s { return %s }; return %s'",
report.Render(pass, cond),
report.Render(pass, origCond), report.Render(pass, ret1), report.Render(pass, ret2)),
report.FilterGenerated())
}
code.Preorder(pass, fn, (*ast.BlockStmt)(nil))
return nil, nil
}
func negate(expr ast.Expr) ast.Expr {
switch expr := expr.(type) {
case *ast.BinaryExpr:
out := *expr
switch expr.Op {
case token.EQL:
out.Op = token.NEQ
case token.LSS:
out.Op = token.GEQ
case token.GTR:
out.Op = token.LEQ
case token.NEQ:
out.Op = token.EQL
case token.LEQ:
out.Op = token.GTR
case token.GEQ:
out.Op = token.LSS
}
return &out
case *ast.Ident, *ast.CallExpr, *ast.IndexExpr, *ast.StarExpr:
return &ast.UnaryExpr{
Op: token.NOT,
X: expr,
}
case *ast.UnaryExpr:
if expr.Op == token.NOT {
return expr.X
}
return &ast.UnaryExpr{
Op: token.NOT,
X: expr,
}
default:
return &ast.UnaryExpr{
Op: token.NOT,
X: &ast.ParenExpr{
X: expr,
},
}
}
}
// CheckRedundantNilCheckWithLen checks for the following redundant nil-checks:
//
// if x == nil || len(x) == 0 {}
// if x != nil && len(x) != 0 {}
// if x != nil && len(x) == N {} (where N != 0)
// if x != nil && len(x) > N {}
// if x != nil && len(x) >= N {} (where N != 0)
//
func CheckRedundantNilCheckWithLen(pass *analysis.Pass) (interface{}, error) {
isConstZero := func(expr ast.Expr) (isConst bool, isZero bool) {
_, ok := expr.(*ast.BasicLit)
if ok {
return true, astutil.IsIntLiteral(expr, "0")
}
id, ok := expr.(*ast.Ident)
if !ok {
return false, false
}
c, ok := pass.TypesInfo.ObjectOf(id).(*types.Const)
if !ok {
return false, false
}
return true, c.Val().Kind() == constant.Int && c.Val().String() == "0"
}
fn := func(node ast.Node) {
// check that expr is "x || y" or "x && y"
expr := node.(*ast.BinaryExpr)
if expr.Op != token.LOR && expr.Op != token.LAND {
return
}
eqNil := expr.Op == token.LOR
// check that x is "xx == nil" or "xx != nil"
x, ok := expr.X.(*ast.BinaryExpr)
if !ok {
return
}
if eqNil && x.Op != token.EQL {
return
}
if !eqNil && x.Op != token.NEQ {
return
}
xx, ok := x.X.(*ast.Ident)
if !ok {
return
}
if !code.IsNil(pass, x.Y) {
return
}
// check that y is "len(xx) == 0" or "len(xx) ... "
y, ok := expr.Y.(*ast.BinaryExpr)
if !ok {
return
}
if eqNil && y.Op != token.EQL { // must be len(xx) *==* 0
return
}
yx, ok := y.X.(*ast.CallExpr)
if !ok {
return
}
yxFun, ok := yx.Fun.(*ast.Ident)
if !ok || yxFun.Name != "len" || len(yx.Args) != 1 {
return
}
yxArg, ok := yx.Args[knowledge.Arg("len.v")].(*ast.Ident)
if !ok {
return
}
if yxArg.Name != xx.Name {
return
}
if eqNil && !astutil.IsIntLiteral(y.Y, "0") { // must be len(x) == *0*
return
}
if !eqNil {
isConst, isZero := isConstZero(y.Y)
if !isConst {
return
}
switch y.Op {
case token.EQL:
// avoid false positive for "xx != nil && len(xx) == 0"
if isZero {
return
}
case token.GEQ:
// avoid false positive for "xx != nil && len(xx) >= 0"
if isZero {
return
}
case token.NEQ:
// avoid false positive for "xx != nil && len(xx) != "
if !isZero {
return
}
case token.GTR:
// ok
default:
return
}
}
// finally check that xx type is one of array, slice, map or chan
// this is to prevent false positive in case if xx is a pointer to an array
var nilType string
switch pass.TypesInfo.TypeOf(xx).(type) {
case *types.Slice:
nilType = "nil slices"
case *types.Map:
nilType = "nil maps"
case *types.Chan:
nilType = "nil channels"
default:
return
}
report.Report(pass, expr, fmt.Sprintf("should omit nil check; len() for %s is defined as zero", nilType), report.FilterGenerated())
}
code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
return nil, nil
}
var checkSlicingQ = pattern.MustParse(`(SliceExpr x@(Object _) low (CallExpr (Builtin "len") [x]) nil)`)
func CheckSlicing(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
if _, ok := code.Match(pass, checkSlicingQ, node); ok {
expr := node.(*ast.SliceExpr)
report.Report(pass, expr.High,
"should omit second index in slice, s[a:len(s)] is identical to s[a:]",
report.FilterGenerated(),
report.Fixes(edit.Fix("simplify slice expression", edit.Delete(expr.High))))
}
}
code.Preorder(pass, fn, (*ast.SliceExpr)(nil))
return nil, nil
}
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
}
var checkLoopAppendQ = pattern.MustParse(`
(RangeStmt
(Ident "_")
val@(Object _)
_
x
[(AssignStmt [lhs] "=" [(CallExpr (Builtin "append") [lhs val])])]) `)
func CheckLoopAppend(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
m, ok := code.Match(pass, checkLoopAppendQ, node)
if !ok {
return
}
val := m.State["val"].(types.Object)
if refersTo(pass, m.State["lhs"].(ast.Expr), val) {
return
}
src := pass.TypesInfo.TypeOf(m.State["x"].(ast.Expr))
dst := pass.TypesInfo.TypeOf(m.State["lhs"].(ast.Expr))
if !types.Identical(src, dst) {
return
}
r := &ast.AssignStmt{
Lhs: []ast.Expr{m.State["lhs"].(ast.Expr)},
Tok: token.ASSIGN,
Rhs: []ast.Expr{
&ast.CallExpr{
Fun: &ast.Ident{Name: "append"},
Args: []ast.Expr{
m.State["lhs"].(ast.Expr),
m.State["x"].(ast.Expr),
},
Ellipsis: 1,
},
},
}
report.Report(pass, node, fmt.Sprintf("should replace loop with %s", report.Render(pass, r)),
report.ShortRange(),
report.FilterGenerated(),
report.Fixes(edit.Fix("replace loop with call to append", edit.ReplaceWithNode(pass.Fset, node, r))))
}
code.Preorder(pass, fn, (*ast.RangeStmt)(nil))
return nil, nil
}
var (
checkTimeSinceQ = pattern.MustParse(`(CallExpr (SelectorExpr (CallExpr (Function "time.Now") []) (Function "(time.Time).Sub")) [arg])`)
checkTimeSinceR = pattern.MustParse(`(CallExpr (SelectorExpr (Ident "time") (Ident "Since")) [arg])`)
)
func CheckTimeSince(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
if _, edits, ok := code.MatchAndEdit(pass, checkTimeSinceQ, checkTimeSinceR, node); ok {
report.Report(pass, node, "should use time.Since instead of time.Now().Sub",
report.FilterGenerated(),
report.Fixes(edit.Fix("replace with call to time.Since", edits...)))
}
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
var (
checkTimeUntilQ = pattern.MustParse(`(CallExpr (Function "(time.Time).Sub") [(CallExpr (Function "time.Now") [])])`)
checkTimeUntilR = pattern.MustParse(`(CallExpr (SelectorExpr (Ident "time") (Ident "Until")) [arg])`)
)
func CheckTimeUntil(pass *analysis.Pass) (interface{}, error) {
if !code.IsGoVersion(pass, 8) {
return nil, nil
}
fn := func(node ast.Node) {
if _, ok := code.Match(pass, checkTimeUntilQ, node); ok {
if sel, ok := node.(*ast.CallExpr).Fun.(*ast.SelectorExpr); ok {
r := pattern.NodeToAST(checkTimeUntilR.Root, map[string]interface{}{"arg": sel.X}).(ast.Node)
report.Report(pass, node, "should use time.Until instead of t.Sub(time.Now())",
report.FilterGenerated(),
report.Fixes(edit.Fix("replace with call to time.Until", edit.ReplaceWithNode(pass.Fset, node, r))))
} else {
report.Report(pass, node, "should use time.Until instead of t.Sub(time.Now())", report.FilterGenerated())
}
}
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
var (
checkUnnecessaryBlankQ1 = pattern.MustParse(`
(AssignStmt
[_ (Ident "_")]
_
(Or
(IndexExpr _ _)
(UnaryExpr "<-" _))) `)
checkUnnecessaryBlankQ2 = pattern.MustParse(`
(AssignStmt
(Ident "_") _ recv@(UnaryExpr "<-" _))`)
)
func CheckUnnecessaryBlank(pass *analysis.Pass) (interface{}, error) {
fn1 := func(node ast.Node) {
if _, ok := code.Match(pass, checkUnnecessaryBlankQ1, node); ok {
r := *node.(*ast.AssignStmt)
r.Lhs = r.Lhs[0:1]
report.Report(pass, node, "unnecessary assignment to the blank identifier",
report.FilterGenerated(),
report.Fixes(edit.Fix("remove assignment to blank identifier", edit.ReplaceWithNode(pass.Fset, node, &r))))
} else if m, ok := code.Match(pass, checkUnnecessaryBlankQ2, node); ok {
report.Report(pass, node, "unnecessary assignment to the blank identifier",
report.FilterGenerated(),
report.Fixes(edit.Fix("simplify channel receive operation", edit.ReplaceWithNode(pass.Fset, node, m.State["recv"].(ast.Node)))))
}
}
fn3 := func(node ast.Node) {
rs := node.(*ast.RangeStmt)
// for _
if rs.Value == nil && astutil.IsBlank(rs.Key) {
report.Report(pass, rs.Key, "unnecessary assignment to the blank identifier",
report.FilterGenerated(),
report.Fixes(edit.Fix("remove assignment to blank identifier", edit.Delete(edit.Range{rs.Key.Pos(), rs.TokPos + 1}))))
}
// for _, _
if astutil.IsBlank(rs.Key) && astutil.IsBlank(rs.Value) {
// FIXME we should mark both key and value
report.Report(pass, rs.Key, "unnecessary assignment to the blank identifier",
report.FilterGenerated(),
report.Fixes(edit.Fix("remove assignment to blank identifier", edit.Delete(edit.Range{rs.Key.Pos(), rs.TokPos + 1}))))
}
// for x, _
if !astutil.IsBlank(rs.Key) && astutil.IsBlank(rs.Value) {
report.Report(pass, rs.Value, "unnecessary assignment to the blank identifier",
report.FilterGenerated(),
report.Fixes(edit.Fix("remove assignment to blank identifier", edit.Delete(edit.Range{rs.Key.End(), rs.Value.End()}))))
}
}
code.Preorder(pass, fn1, (*ast.AssignStmt)(nil))
if code.IsGoVersion(pass, 4) {
code.Preorder(pass, fn3, (*ast.RangeStmt)(nil))
}
return nil, nil
}
func CheckSimplerStructConversion(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node, stack []ast.Node) {
if unary, ok := stack[len(stack)-2].(*ast.UnaryExpr); ok && unary.Op == token.AND {
// Do not suggest type conversion between pointers
return
}
lit := node.(*ast.CompositeLit)
typ1, _ := pass.TypesInfo.TypeOf(lit.Type).(*types.Named)
if typ1 == nil {
return
}
s1, ok := typ1.Underlying().(*types.Struct)
if !ok {
return
}
var typ2 *types.Named
var ident *ast.Ident
getSelType := func(expr ast.Expr) (types.Type, *ast.Ident, bool) {
sel, ok := expr.(*ast.SelectorExpr)
if !ok {
return nil, nil, false
}
ident, ok := sel.X.(*ast.Ident)
if !ok {
return nil, nil, false
}
typ := pass.TypesInfo.TypeOf(sel.X)
return typ, ident, typ != nil
}
if len(lit.Elts) == 0 {
return
}
if s1.NumFields() != len(lit.Elts) {
return
}
for i, elt := range lit.Elts {
var t types.Type
var id *ast.Ident
var ok bool
switch elt := elt.(type) {
case *ast.SelectorExpr:
t, id, ok = getSelType(elt)
if !ok {
return
}
if i >= s1.NumFields() || s1.Field(i).Name() != elt.Sel.Name {
return
}
case *ast.KeyValueExpr:
var sel *ast.SelectorExpr
sel, ok = elt.Value.(*ast.SelectorExpr)
if !ok {
return
}
if elt.Key.(*ast.Ident).Name != sel.Sel.Name {
return
}
t, id, ok = getSelType(elt.Value)
}
if !ok {
return
}
// All fields must be initialized from the same object
if ident != nil && ident.Obj != id.Obj {
return
}
typ2, _ = t.(*types.Named)
if typ2 == nil {
return
}
ident = id
}
if typ2 == nil {
return
}
if typ1.Obj().Pkg() != typ2.Obj().Pkg() {
// Do not suggest type conversions between different
// packages. Types in different packages might only match
// by coincidence. Furthermore, if the dependency ever
// adds more fields to its type, it could break the code
// that relies on the type conversion to work.
return
}
s2, ok := typ2.Underlying().(*types.Struct)
if !ok {
return
}
if typ1 == typ2 {
return
}
if code.IsGoVersion(pass, 8) {
if !types.IdenticalIgnoreTags(s1, s2) {
return
}
} else {
if !types.Identical(s1, s2) {
return
}
}
r := &ast.CallExpr{
Fun: lit.Type,
Args: []ast.Expr{ident},
}
report.Report(pass, node,
fmt.Sprintf("should convert %s (type %s) to %s instead of using struct literal", ident.Name, typ2.Obj().Name(), typ1.Obj().Name()),
report.FilterGenerated(),
report.Fixes(edit.Fix("use type conversion", edit.ReplaceWithNode(pass.Fset, node, r))))
}
code.PreorderStack(pass, fn, (*ast.CompositeLit)(nil))
return nil, nil
}
func CheckTrim(pass *analysis.Pass) (interface{}, error) {
sameNonDynamic := func(node1, node2 ast.Node) bool {
if reflect.TypeOf(node1) != reflect.TypeOf(node2) {
return false
}
switch node1 := node1.(type) {
case *ast.Ident:
return node1.Obj == node2.(*ast.Ident).Obj
case *ast.SelectorExpr, *ast.IndexExpr:
return astutil.Equal(node1, node2)
case *ast.BasicLit:
return astutil.Equal(node1, node2)
}
return false
}
isLenOnIdent := func(fn ast.Expr, ident ast.Expr) bool {
call, ok := fn.(*ast.CallExpr)
if !ok {
return false
}
if !code.IsCallTo(pass, call, "len") {
return false
}
if len(call.Args) != 1 {
return false
}
return sameNonDynamic(call.Args[knowledge.Arg("len.v")], ident)
}
fn := func(node ast.Node) {
var pkg string
var fun string
ifstmt := node.(*ast.IfStmt)
if ifstmt.Init != nil {
return
}
if ifstmt.Else != nil {
return
}
if len(ifstmt.Body.List) != 1 {
return
}
condCall, ok := ifstmt.Cond.(*ast.CallExpr)
if !ok {
return
}
condCallName := code.CallName(pass, condCall)
switch condCallName {
case "strings.HasPrefix":
pkg = "strings"
fun = "HasPrefix"
case "strings.HasSuffix":
pkg = "strings"
fun = "HasSuffix"
case "strings.Contains":
pkg = "strings"
fun = "Contains"
case "bytes.HasPrefix":
pkg = "bytes"
fun = "HasPrefix"
case "bytes.HasSuffix":
pkg = "bytes"
fun = "HasSuffix"
case "bytes.Contains":
pkg = "bytes"
fun = "Contains"
default:
return
}
assign, ok := ifstmt.Body.List[0].(*ast.AssignStmt)
if !ok {
return
}
if assign.Tok != token.ASSIGN {
return
}
if len(assign.Lhs) != 1 || len(assign.Rhs) != 1 {
return
}
if !sameNonDynamic(condCall.Args[0], assign.Lhs[0]) {
return
}
switch rhs := assign.Rhs[0].(type) {
case *ast.CallExpr:
if len(rhs.Args) < 2 || !sameNonDynamic(condCall.Args[0], rhs.Args[0]) || !sameNonDynamic(condCall.Args[1], rhs.Args[1]) {
return
}
rhsName := code.CallName(pass, rhs)
if condCallName == "strings.HasPrefix" && rhsName == "strings.TrimPrefix" ||
condCallName == "strings.HasSuffix" && rhsName == "strings.TrimSuffix" ||
condCallName == "strings.Contains" && rhsName == "strings.Replace" ||
condCallName == "bytes.HasPrefix" && rhsName == "bytes.TrimPrefix" ||
condCallName == "bytes.HasSuffix" && rhsName == "bytes.TrimSuffix" ||
condCallName == "bytes.Contains" && rhsName == "bytes.Replace" {
report.Report(pass, ifstmt, fmt.Sprintf("should replace this if statement with an unconditional %s", rhsName), report.FilterGenerated())
}
case *ast.SliceExpr:
slice := rhs
if !ok {
return
}
if slice.Slice3 {
return
}
if !sameNonDynamic(slice.X, condCall.Args[0]) {
return
}
validateOffset := func(off ast.Expr) bool {
switch off := off.(type) {
case *ast.CallExpr:
return isLenOnIdent(off, condCall.Args[1])
case *ast.BasicLit:
if pkg != "strings" {
return false
}
if _, ok := condCall.Args[1].(*ast.BasicLit); !ok {
// Only allow manual slicing with an integer
// literal if the second argument to HasPrefix
// was a string literal.
return false
}
s, ok1 := code.ExprToString(pass, condCall.Args[1])
n, ok2 := code.ExprToInt(pass, off)
if !ok1 || !ok2 || n != int64(len(s)) {
return false
}
return true
default:
return false
}
}
switch fun {
case "HasPrefix":
// TODO(dh) We could detect a High that is len(s), but another
// rule will already flag that, anyway.
if slice.High != nil {
return
}
if !validateOffset(slice.Low) {
return
}
case "HasSuffix":
if slice.Low != nil {
n, ok := code.ExprToInt(pass, slice.Low)
if !ok || n != 0 {
return
}
}
switch index := slice.High.(type) {
case *ast.BinaryExpr:
if index.Op != token.SUB {
return
}
if !isLenOnIdent(index.X, condCall.Args[0]) {
return
}
if !validateOffset(index.Y) {
return
}
default:
return
}
default:
return
}
var replacement string
switch fun {
case "HasPrefix":
replacement = "TrimPrefix"
case "HasSuffix":
replacement = "TrimSuffix"
}
report.Report(pass, ifstmt, fmt.Sprintf("should replace this if statement with an unconditional %s.%s", pkg, replacement),
report.ShortRange(),
report.FilterGenerated())
}
}
code.Preorder(pass, fn, (*ast.IfStmt)(nil))
return nil, nil
}
var (
checkLoopSlideQ = pattern.MustParse(`
(ForStmt
(AssignStmt initvar@(Ident _) _ (BasicLit "INT" "0"))
(BinaryExpr initvar "<" limit@(Ident _))
(IncDecStmt initvar "++")
[(AssignStmt
(IndexExpr slice@(Ident _) initvar)
"="
(IndexExpr slice (BinaryExpr offset@(Ident _) "+" initvar)))])`)
checkLoopSlideR = pattern.MustParse(`
(CallExpr
(Ident "copy")
[(SliceExpr slice nil limit nil)
(SliceExpr slice offset nil nil)])`)
)
func CheckLoopSlide(pass *analysis.Pass) (interface{}, error) {
// TODO(dh): detect bs[i+offset] in addition to bs[offset+i]
// TODO(dh): consider merging this function with LintLoopCopy
// TODO(dh): detect length that is an expression, not a variable name
// TODO(dh): support sliding to a different offset than the beginning of the slice
fn := func(node ast.Node) {
loop := node.(*ast.ForStmt)
m, edits, ok := code.MatchAndEdit(pass, checkLoopSlideQ, checkLoopSlideR, loop)
if !ok {
return
}
if _, ok := pass.TypesInfo.TypeOf(m.State["slice"].(*ast.Ident)).Underlying().(*types.Slice); !ok {
return
}
report.Report(pass, loop, "should use copy() instead of loop for sliding slice elements",
report.ShortRange(),
report.FilterGenerated(),
report.Fixes(edit.Fix("use copy() instead of loop", edits...)))
}
code.Preorder(pass, fn, (*ast.ForStmt)(nil))
return nil, nil
}
var (
checkMakeLenCapQ1 = pattern.MustParse(`(CallExpr (Builtin "make") [typ size@(BasicLit "INT" "0")])`)
checkMakeLenCapQ2 = pattern.MustParse(`(CallExpr (Builtin "make") [typ size size])`)
)
func CheckMakeLenCap(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
if pass.Pkg.Path() == "runtime_test" && filepath.Base(pass.Fset.Position(node.Pos()).Filename) == "map_test.go" {
// special case of runtime tests testing map creation
return
}
if m, ok := code.Match(pass, checkMakeLenCapQ1, node); ok {
T := m.State["typ"].(ast.Expr)
size := m.State["size"].(ast.Node)
switch pass.TypesInfo.TypeOf(T).Underlying().(type) {
case *types.Slice, *types.Map:
return
}
report.Report(pass, size, fmt.Sprintf("should use make(%s) instead", report.Render(pass, T)), report.FilterGenerated())
} else if m, ok := code.Match(pass, checkMakeLenCapQ2, node); ok {
// TODO(dh): don't consider sizes identical if they're
// dynamic. for example: make(T, <-ch, <-ch).
T := m.State["typ"].(ast.Expr)
size := m.State["size"].(ast.Node)
report.Report(pass, size,
fmt.Sprintf("should use make(%s, %s) instead", report.Render(pass, T), report.Render(pass, size)),
report.FilterGenerated())
}
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
var (
checkAssertNotNilFn1Q = pattern.MustParse(`
(IfStmt
(AssignStmt [(Ident "_") ok@(Object _)] _ [(TypeAssertExpr assert@(Object _) _)])
(Or
(BinaryExpr ok "&&" (BinaryExpr assert "!=" (Builtin "nil")))
(BinaryExpr (BinaryExpr assert "!=" (Builtin "nil")) "&&" ok))
_
_)`)
checkAssertNotNilFn2Q = pattern.MustParse(`
(IfStmt
nil
(BinaryExpr lhs@(Object _) "!=" (Builtin "nil"))
[
ifstmt@(IfStmt
(AssignStmt [(Ident "_") ok@(Object _)] _ [(TypeAssertExpr lhs _)])
ok
_
nil)
]
nil)`)
)
func CheckAssertNotNil(pass *analysis.Pass) (interface{}, error) {
fn1 := func(node ast.Node) {
m, ok := code.Match(pass, checkAssertNotNilFn1Q, node)
if !ok {
return
}
assert := m.State["assert"].(types.Object)
assign := m.State["ok"].(types.Object)
report.Report(pass, node, fmt.Sprintf("when %s is true, %s can't be nil", assign.Name(), assert.Name()),
report.ShortRange(),
report.FilterGenerated())
}
fn2 := func(node ast.Node) {
m, ok := code.Match(pass, checkAssertNotNilFn2Q, node)
if !ok {
return
}
ifstmt := m.State["ifstmt"].(*ast.IfStmt)
lhs := m.State["lhs"].(types.Object)
assignIdent := m.State["ok"].(types.Object)
report.Report(pass, ifstmt, fmt.Sprintf("when %s is true, %s can't be nil", assignIdent.Name(), lhs.Name()),
report.ShortRange(),
report.FilterGenerated())
}
// OPT(dh): merge fn1 and fn2
code.Preorder(pass, fn1, (*ast.IfStmt)(nil))
code.Preorder(pass, fn2, (*ast.IfStmt)(nil))
return nil, nil
}
func CheckDeclareAssign(pass *analysis.Pass) (interface{}, error) {
hasMultipleAssignments := func(root ast.Node, ident *ast.Ident) bool {
num := 0
ast.Inspect(root, func(node ast.Node) bool {
if num >= 2 {
return false
}
assign, ok := node.(*ast.AssignStmt)
if !ok {
return true
}
for _, lhs := range assign.Lhs {
if oident, ok := lhs.(*ast.Ident); ok {
if oident.Obj == ident.Obj {
num++
}
}
}
return true
})
return num >= 2
}
fn := func(node ast.Node) {
block := node.(*ast.BlockStmt)
if len(block.List) < 2 {
return
}
for i, stmt := range block.List[:len(block.List)-1] {
_ = i
decl, ok := stmt.(*ast.DeclStmt)
if !ok {
continue
}
gdecl, ok := decl.Decl.(*ast.GenDecl)
if !ok || gdecl.Tok != token.VAR || len(gdecl.Specs) != 1 {
continue
}
vspec, ok := gdecl.Specs[0].(*ast.ValueSpec)
if !ok || len(vspec.Names) != 1 || len(vspec.Values) != 0 {
continue
}
assign, ok := block.List[i+1].(*ast.AssignStmt)
if !ok || assign.Tok != token.ASSIGN {
continue
}
if len(assign.Lhs) != 1 || len(assign.Rhs) != 1 {
continue
}
ident, ok := assign.Lhs[0].(*ast.Ident)
if !ok {
continue
}
if vspec.Names[0].Obj != ident.Obj {
continue
}
if refersTo(pass, assign.Rhs[0], pass.TypesInfo.ObjectOf(ident)) {
continue
}
if hasMultipleAssignments(block, ident) {
continue
}
r := &ast.GenDecl{
Specs: []ast.Spec{
&ast.ValueSpec{
Names: vspec.Names,
Values: []ast.Expr{assign.Rhs[0]},
Type: vspec.Type,
},
},
Tok: gdecl.Tok,
}
report.Report(pass, decl, "should merge variable declaration with assignment on next line",
report.FilterGenerated(),
report.Fixes(edit.Fix("merge declaration with assignment", edit.ReplaceWithNode(pass.Fset, edit.Range{decl.Pos(), assign.End()}, r))))
}
}
code.Preorder(pass, fn, (*ast.BlockStmt)(nil))
return nil, nil
}
func CheckRedundantBreak(pass *analysis.Pass) (interface{}, error) {
fn1 := func(node ast.Node) {
clause := node.(*ast.CaseClause)
if len(clause.Body) < 2 {
return
}
branch, ok := clause.Body[len(clause.Body)-1].(*ast.BranchStmt)
if !ok || branch.Tok != token.BREAK || branch.Label != nil {
return
}
report.Report(pass, branch, "redundant break statement", report.FilterGenerated())
}
fn2 := func(node ast.Node) {
var ret *ast.FieldList
var body *ast.BlockStmt
switch x := node.(type) {
case *ast.FuncDecl:
ret = x.Type.Results
body = x.Body
case *ast.FuncLit:
ret = x.Type.Results
body = x.Body
default:
lint.ExhaustiveTypeSwitch(node)
}
// if the func has results, a return can't be redundant.
// similarly, if there are no statements, there can be
// no return.
if ret != nil || body == nil || len(body.List) < 1 {
return
}
rst, ok := body.List[len(body.List)-1].(*ast.ReturnStmt)
if !ok {
return
}
// we don't need to check rst.Results as we already
// checked x.Type.Results to be nil.
report.Report(pass, rst, "redundant return statement", report.FilterGenerated())
}
code.Preorder(pass, fn1, (*ast.CaseClause)(nil))
code.Preorder(pass, fn2, (*ast.FuncDecl)(nil), (*ast.FuncLit)(nil))
return nil, nil
}
func isStringer(T types.Type, msCache *typeutil.MethodSetCache) bool {
ms := msCache.MethodSet(T)
sel := ms.Lookup(nil, "String")
if sel == nil {
return false
}
fn, ok := sel.Obj().(*types.Func)
if !ok {
// should be unreachable
return false
}
sig := fn.Type().(*types.Signature)
if sig.Params().Len() != 0 {
return false
}
if sig.Results().Len() != 1 {
return false
}
if !typeutil.IsType(sig.Results().At(0).Type(), "string") {
return false
}
return true
}
func isFormatter(T types.Type, msCache *typeutil.MethodSetCache) bool {
// TODO(dh): this function also exists in staticcheck/lint.go β deduplicate.
ms := msCache.MethodSet(T)
sel := ms.Lookup(nil, "Format")
if sel == nil {
return false
}
fn, ok := sel.Obj().(*types.Func)
if !ok {
// should be unreachable
return false
}
sig := fn.Type().(*types.Signature)
if sig.Params().Len() != 2 {
return false
}
// TODO(dh): check the types of the arguments for more
// precision
if sig.Results().Len() != 0 {
return false
}
return true
}
var checkRedundantSprintfQ = pattern.MustParse(`(CallExpr (Function "fmt.Sprintf") [format arg])`)
func CheckRedundantSprintf(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
m, ok := code.Match(pass, checkRedundantSprintfQ, node)
if !ok {
return
}
format := m.State["format"].(ast.Expr)
arg := m.State["arg"].(ast.Expr)
// TODO(dh): should we really support named constants here?
// shouldn't we only look for string literals? to avoid false
// positives via build tags?
if s, ok := code.ExprToString(pass, format); !ok || s != "%s" {
return
}
typ := pass.TypesInfo.TypeOf(arg)
irpkg := pass.ResultOf[buildir.Analyzer].(*buildir.IR).Pkg
if types.TypeString(typ, nil) == "reflect.Value" {
// printing with %s produces output different from using
// the String method
return
}
if isFormatter(typ, &irpkg.Prog.MethodSets) {
// the type may choose to handle %s in arbitrary ways
return
}
if isStringer(typ, &irpkg.Prog.MethodSets) {
replacement := &ast.CallExpr{
Fun: &ast.SelectorExpr{
X: arg,
Sel: &ast.Ident{Name: "String"},
},
}
report.Report(pass, node, "should use String() instead of fmt.Sprintf",
report.Fixes(edit.Fix("replace with call to String method", edit.ReplaceWithNode(pass.Fset, node, replacement))))
} else if typ == types.Universe.Lookup("string").Type() {
report.Report(pass, node, "the argument is already a string, there's no need to use fmt.Sprintf",
report.FilterGenerated(),
report.Fixes(edit.Fix("remove unnecessary call to fmt.Sprintf", edit.ReplaceWithNode(pass.Fset, node, arg))))
} else if typ.Underlying() == types.Universe.Lookup("string").Type() {
replacement := &ast.CallExpr{
Fun: &ast.Ident{Name: "string"},
Args: []ast.Expr{arg},
}
report.Report(pass, node, "the argument's underlying type is a string, should use a simple conversion instead of fmt.Sprintf",
report.FilterGenerated(),
report.Fixes(edit.Fix("replace with conversion to string", edit.ReplaceWithNode(pass.Fset, node, replacement))))
} else if slice, ok := typ.Underlying().(*types.Slice); ok && slice.Elem() == types.Universe.Lookup("byte").Type() {
// Note that we check slice.Elem(), not slice.Elem().Underlying, because of https://github.com/golang/go/issues/23536
replacement := &ast.CallExpr{
Fun: &ast.Ident{Name: "string"},
Args: []ast.Expr{arg},
}
report.Report(pass, node, "the argument's underlying type is a slice of bytes, should use a simple conversion instead of fmt.Sprintf",
report.FilterGenerated(),
report.Fixes(edit.Fix("replace with conversion to string", edit.ReplaceWithNode(pass.Fset, node, replacement))))
}
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
var (
checkErrorsNewSprintfQ = pattern.MustParse(`(CallExpr (Function "errors.New") [(CallExpr (Function "fmt.Sprintf") args)])`)
checkErrorsNewSprintfR = pattern.MustParse(`(CallExpr (SelectorExpr (Ident "fmt") (Ident "Errorf")) args)`)
)
func CheckErrorsNewSprintf(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
if _, edits, ok := code.MatchAndEdit(pass, checkErrorsNewSprintfQ, checkErrorsNewSprintfR, node); ok {
// TODO(dh): the suggested fix may leave an unused import behind
report.Report(pass, node, "should use fmt.Errorf(...) instead of errors.New(fmt.Sprintf(...))",
report.FilterGenerated(),
report.Fixes(edit.Fix("use fmt.Errorf", edits...)))
}
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
func CheckRangeStringRunes(pass *analysis.Pass) (interface{}, error) {
return sharedcheck.CheckRangeStringRunes(pass)
}
var checkNilCheckAroundRangeQ = pattern.MustParse(`
(IfStmt
nil
(BinaryExpr x@(Object _) "!=" (Builtin "nil"))
[(RangeStmt _ _ _ x _)]
nil)`)
func CheckNilCheckAroundRange(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
m, ok := code.Match(pass, checkNilCheckAroundRangeQ, node)
if !ok {
return
}
switch m.State["x"].(types.Object).Type().Underlying().(type) {
case *types.Slice, *types.Map:
report.Report(pass, node, "unnecessary nil check around range",
report.ShortRange(),
report.FilterGenerated())
}
}
code.Preorder(pass, fn, (*ast.IfStmt)(nil))
return nil, nil
}
func isPermissibleSort(pass *analysis.Pass, node ast.Node) bool {
call := node.(*ast.CallExpr)
typeconv, ok := call.Args[0].(*ast.CallExpr)
if !ok {
return true
}
sel, ok := typeconv.Fun.(*ast.SelectorExpr)
if !ok {
return true
}
name := code.SelectorName(pass, sel)
switch name {
case "sort.IntSlice", "sort.Float64Slice", "sort.StringSlice":
default:
return true
}
return false
}
func CheckSortHelpers(pass *analysis.Pass) (interface{}, error) {
type Error struct {
node ast.Node
msg string
}
var allErrors []Error
fn := func(node ast.Node) {
var body *ast.BlockStmt
switch node := node.(type) {
case *ast.FuncLit:
body = node.Body
case *ast.FuncDecl:
body = node.Body
default:
lint.ExhaustiveTypeSwitch(node)
}
if body == nil {
return
}
var errors []Error
permissible := false
fnSorts := func(node ast.Node) bool {
if permissible {
return false
}
if !code.IsCallTo(pass, node, "sort.Sort") {
return true
}
if isPermissibleSort(pass, node) {
permissible = true
return false
}
call := node.(*ast.CallExpr)
// isPermissibleSort guarantees that this type assertion will succeed
typeconv := call.Args[knowledge.Arg("sort.Sort.data")].(*ast.CallExpr)
sel := typeconv.Fun.(*ast.SelectorExpr)
name := code.SelectorName(pass, sel)
switch name {
case "sort.IntSlice":
errors = append(errors, Error{node, "should use sort.Ints(...) instead of sort.Sort(sort.IntSlice(...))"})
case "sort.Float64Slice":
errors = append(errors, Error{node, "should use sort.Float64s(...) instead of sort.Sort(sort.Float64Slice(...))"})
case "sort.StringSlice":
errors = append(errors, Error{node, "should use sort.Strings(...) instead of sort.Sort(sort.StringSlice(...))"})
}
return true
}
ast.Inspect(body, fnSorts)
if permissible {
return
}
allErrors = append(allErrors, errors...)
}
code.Preorder(pass, fn, (*ast.FuncLit)(nil), (*ast.FuncDecl)(nil))
sort.Slice(allErrors, func(i, j int) bool {
return allErrors[i].node.Pos() < allErrors[j].node.Pos()
})
var prev token.Pos
for _, err := range allErrors {
if err.node.Pos() == prev {
continue
}
prev = err.node.Pos()
report.Report(pass, err.node, err.msg, report.FilterGenerated())
}
return nil, nil
}
var checkGuardedDeleteQ = pattern.MustParse(`
(IfStmt
(AssignStmt
[(Ident "_") ok@(Ident _)]
":="
(IndexExpr m key))
ok
[call@(CallExpr (Builtin "delete") [m key])]
nil)`)
func CheckGuardedDelete(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
if m, ok := code.Match(pass, checkGuardedDeleteQ, node); ok {
report.Report(pass, node, "unnecessary guard around call to delete",
report.ShortRange(),
report.FilterGenerated(),
report.Fixes(edit.Fix("remove guard", edit.ReplaceWithNode(pass.Fset, node, m.State["call"].(ast.Node)))))
}
}
code.Preorder(pass, fn, (*ast.IfStmt)(nil))
return nil, nil
}
var (
checkSimplifyTypeSwitchQ = pattern.MustParse(`
(TypeSwitchStmt
nil
expr@(TypeAssertExpr ident@(Ident _) _)
body)`)
checkSimplifyTypeSwitchR = pattern.MustParse(`(AssignStmt ident ":=" expr)`)
)
func CheckSimplifyTypeSwitch(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
m, ok := code.Match(pass, checkSimplifyTypeSwitchQ, node)
if !ok {
return
}
stmt := node.(*ast.TypeSwitchStmt)
expr := m.State["expr"].(ast.Node)
ident := m.State["ident"].(*ast.Ident)
x := pass.TypesInfo.ObjectOf(ident)
var allOffenders []*ast.TypeAssertExpr
canSuggestFix := true
for _, clause := range stmt.Body.List {
clause := clause.(*ast.CaseClause)
if len(clause.List) != 1 {
continue
}
hasUnrelatedAssertion := false
var offenders []*ast.TypeAssertExpr
ast.Inspect(clause, func(node ast.Node) bool {
assert2, ok := node.(*ast.TypeAssertExpr)
if !ok {
return true
}
ident, ok := assert2.X.(*ast.Ident)
if !ok {
hasUnrelatedAssertion = true
return false
}
if pass.TypesInfo.ObjectOf(ident) != x {
hasUnrelatedAssertion = true
return false
}
if !types.Identical(pass.TypesInfo.TypeOf(clause.List[0]), pass.TypesInfo.TypeOf(assert2.Type)) {
hasUnrelatedAssertion = true
return false
}
offenders = append(offenders, assert2)
return true
})
if !hasUnrelatedAssertion {
// don't flag cases that have other type assertions
// unrelated to the one in the case clause. often
// times, this is done for symmetry, when two
// different values have to be asserted to the same
// type.
allOffenders = append(allOffenders, offenders...)
}
canSuggestFix = canSuggestFix && !hasUnrelatedAssertion
}
if len(allOffenders) != 0 {
var opts []report.Option
for _, offender := range allOffenders {
opts = append(opts, report.Related(offender, "could eliminate this type assertion"))
}
opts = append(opts, report.FilterGenerated())
msg := fmt.Sprintf("assigning the result of this type assertion to a variable (switch %s := %s.(type)) could eliminate type assertions in switch cases",
report.Render(pass, ident), report.Render(pass, ident))
if canSuggestFix {
var edits []analysis.TextEdit
edits = append(edits, edit.ReplaceWithPattern(pass, checkSimplifyTypeSwitchR, m.State, expr))
for _, offender := range allOffenders {
edits = append(edits, edit.ReplaceWithNode(pass.Fset, offender, offender.X))
}
opts = append(opts, report.Fixes(edit.Fix("simplify type switch", edits...)))
report.Report(pass, expr, msg, opts...)
} else {
report.Report(pass, expr, msg, opts...)
}
}
}
code.Preorder(pass, fn, (*ast.TypeSwitchStmt)(nil))
return nil, nil
}
func CheckRedundantCanonicalHeaderKey(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
call := node.(*ast.CallExpr)
callName := code.CallName(pass, call)
switch callName {
case "(net/http.Header).Add", "(net/http.Header).Del", "(net/http.Header).Get", "(net/http.Header).Set":
default:
return
}
if !code.IsCallTo(pass, call.Args[0], "net/http.CanonicalHeaderKey") {
return
}
report.Report(pass, call,
fmt.Sprintf("calling net/http.CanonicalHeaderKey on the 'key' argument of %s is redundant", callName),
report.FilterGenerated(),
report.Fixes(edit.Fix("remove call to CanonicalHeaderKey", edit.ReplaceWithNode(pass.Fset, call.Args[0], call.Args[0].(*ast.CallExpr).Args[0]))))
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
var checkUnnecessaryGuardQ = pattern.MustParse(`
(Or
(IfStmt
(AssignStmt [(Ident "_") ok@(Ident _)] ":=" indexexpr@(IndexExpr _ _))
ok
set@(AssignStmt indexexpr "=" (CallExpr (Builtin "append") indexexpr:values))
(AssignStmt indexexpr "=" (CompositeLit _ values)))
(IfStmt
(AssignStmt [(Ident "_") ok] ":=" indexexpr@(IndexExpr _ _))
ok
set@(AssignStmt indexexpr "+=" value)
(AssignStmt indexexpr "=" value))
(IfStmt
(AssignStmt [(Ident "_") ok] ":=" indexexpr@(IndexExpr _ _))
ok
set@(IncDecStmt indexexpr "++")
(AssignStmt indexexpr "=" (BasicLit "INT" "1"))))`)
func CheckUnnecessaryGuard(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
if m, ok := code.Match(pass, checkUnnecessaryGuardQ, node); ok {
if code.MayHaveSideEffects(pass, m.State["indexexpr"].(ast.Expr), nil) {
return
}
report.Report(pass, node, "unnecessary guard around map access",
report.ShortRange(),
report.Fixes(edit.Fix("simplify map access", edit.ReplaceWithNode(pass.Fset, node, m.State["set"].(ast.Node)))))
}
}
code.Preorder(pass, fn, (*ast.IfStmt)(nil))
return nil, nil
}
var (
checkElaborateSleepQ = pattern.MustParse(`(SelectStmt (CommClause (UnaryExpr "<-" (CallExpr (Function "time.After") [arg])) body))`)
checkElaborateSleepR = pattern.MustParse(`(CallExpr (SelectorExpr (Ident "time") (Ident "Sleep")) [arg])`)
)
func CheckElaborateSleep(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
if m, ok := code.Match(pass, checkElaborateSleepQ, node); ok {
if body, ok := m.State["body"].([]ast.Stmt); ok && len(body) == 0 {
report.Report(pass, node, "should use time.Sleep instead of elaborate way of sleeping",
report.ShortRange(),
report.FilterGenerated(),
report.Fixes(edit.Fix("Use time.Sleep", edit.ReplaceWithPattern(pass, checkElaborateSleepR, m.State, node))))
} else {
// TODO(dh): we could make a suggested fix if the body
// doesn't declare or shadow any identifiers
report.Report(pass, node, "should use time.Sleep instead of elaborate way of sleeping",
report.ShortRange(),
report.FilterGenerated())
}
}
}
code.Preorder(pass, fn, (*ast.SelectStmt)(nil))
return nil, nil
}
var checkPrintSprintQ = pattern.MustParse(`
(Or
(CallExpr
fn@(Or
(Function "fmt.Print")
(Function "fmt.Sprint")
(Function "fmt.Println")
(Function "fmt.Sprintln"))
[(CallExpr (Function "fmt.Sprintf") f:_)])
(CallExpr
fn@(Or
(Function "fmt.Fprint")
(Function "fmt.Fprintln"))
[_ (CallExpr (Function "fmt.Sprintf") f:_)]))`)
func CheckPrintSprintf(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
m, ok := code.Match(pass, checkPrintSprintQ, node)
if !ok {
return
}
name := m.State["fn"].(*types.Func).Name()
var msg string
switch name {
case "Print", "Fprint", "Sprint":
newname := name + "f"
msg = fmt.Sprintf("should use fmt.%s instead of fmt.%s(fmt.Sprintf(...))", newname, name)
case "Println", "Fprintln", "Sprintln":
if _, ok := m.State["f"].(*ast.BasicLit); !ok {
// This may be an instance of
// fmt.Println(fmt.Sprintf(arg, ...)) where arg is an
// externally provided format string and the caller
// cannot guarantee that the format string ends with a
// newline.
return
}
newname := name[:len(name)-2] + "f"
msg = fmt.Sprintf("should use fmt.%s instead of fmt.%s(fmt.Sprintf(...)) (but don't forget the newline)", newname, name)
}
report.Report(pass, node, msg,
report.FilterGenerated())
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
var checkSprintLiteralQ = pattern.MustParse(`
(CallExpr
fn@(Or
(Function "fmt.Sprint")
(Function "fmt.Sprintf"))
[lit@(BasicLit "STRING" _)])`)
func CheckSprintLiteral(pass *analysis.Pass) (interface{}, error) {
// We only flag calls with string literals, not expressions of
// type string, because some people use fmt.Sprint(s) as a pattern
// for copying strings, which may be useful when extracting a small
// substring from a large string.
fn := func(node ast.Node) {
m, ok := code.Match(pass, checkSprintLiteralQ, node)
if !ok {
return
}
callee := m.State["fn"].(*types.Func)
lit := m.State["lit"].(*ast.BasicLit)
if callee.Name() == "Sprintf" {
if strings.ContainsRune(lit.Value, '%') {
// This might be a format string
return
}
}
report.Report(pass, node, fmt.Sprintf("unnecessary use of fmt.%s", callee.Name()),
report.FilterGenerated(),
report.Fixes(edit.Fix("Replace with string literal", edit.ReplaceWithNode(pass.Fset, node, lit))))
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
func CheckSameTypeTypeAssertion(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
expr := node.(*ast.TypeAssertExpr)
if expr.Type == nil {
// skip type switches
//
// TODO(dh): we could flag type switches, too, when a case
// statement has the same type as expr.X β however,
// depending on the location of that case, it might behave
// identically to a default branch. we need to think
// carefully about the instances we want to flag. We also
// have to take nil interface values into consideration.
//
// It might make more sense to extend SA4020 to handle
// this.
return
}
t1 := pass.TypesInfo.TypeOf(expr.Type)
t2 := pass.TypesInfo.TypeOf(expr.X)
if types.IsInterface(t1) && types.Identical(t1, t2) {
report.Report(pass, expr,
fmt.Sprintf("type assertion to the same type: %s already has type %s", report.Render(pass, expr.X), report.Render(pass, expr.Type)),
report.FilterGenerated())
}
}
// TODO(dh): add suggested fixes. we need different fixes depending on the context:
// - assignment with 1 or 2 lhs
// - assignment to blank identifiers (as the first, second or both lhs)
// - initializers in if statements, with the same variations as above
code.Preorder(pass, fn, (*ast.TypeAssertExpr)(nil))
return nil, nil
}
go-tools-2021.1.2/simple/lint_test.go 0000664 0000000 0000000 00000003473 14143223131 0017330 0 ustar 00root root 0000000 0000000 package simple
import (
"testing"
"honnef.co/go/tools/lint/testutil"
)
func TestAll(t *testing.T) {
checks := map[string][]testutil.Test{
"S1000": {{Dir: "single-case-select"}},
"S1001": {{Dir: "copy"}},
"S1002": {{Dir: "bool-cmp"}},
"S1003": {{Dir: "contains"}},
"S1004": {{Dir: "compare"}},
"S1005": {{Dir: "CheckBlankOK"}, {Dir: "receive-blank"}, {Dir: "range_go13", Version: "1.3"}, {Dir: "range_go14", Version: "1.4"}},
"S1006": {{Dir: "for-true"}, {Dir: "generated"}},
"S1007": {{Dir: "regexp-raw"}},
"S1008": {{Dir: "if-return"}},
"S1009": {{Dir: "nil-len"}},
"S1010": {{Dir: "slicing"}},
"S1011": {{Dir: "loop-append"}},
"S1012": {{Dir: "time-since"}},
"S1016": {{Dir: "convert"}, {Dir: "convert_go17", Version: "1.7"}, {Dir: "convert_go18", Version: "1.8"}},
"S1017": {{Dir: "trim"}},
"S1018": {{Dir: "CheckLoopSlide"}},
"S1019": {{Dir: "CheckMakeLenCap"}},
"S1020": {{Dir: "CheckAssertNotNil"}},
"S1021": {{Dir: "CheckDeclareAssign"}},
"S1023": {{Dir: "CheckRedundantBreak"}, {Dir: "CheckRedundantReturn"}},
"S1024": {{Dir: "CheckTimeUntil_go17", Version: "1.7"}, {Dir: "CheckTimeUntil_go18", Version: "1.8"}},
"S1025": {{Dir: "CheckRedundantSprintf"}},
"S1028": {{Dir: "CheckErrorsNewSprintf"}},
"S1029": {{Dir: "CheckRangeStringRunes"}},
"S1030": {{Dir: "CheckBytesBufferConversions"}},
"S1031": {{Dir: "CheckNilCheckAroundRange"}},
"S1032": {{Dir: "CheckSortHelpers"}},
"S1033": {{Dir: "CheckGuardedDelete"}},
"S1034": {{Dir: "CheckSimplifyTypeSwitch"}},
"S1035": {{Dir: "CheckRedundantCanonicalHeaderKey"}},
"S1036": {{Dir: "CheckUnnecessaryGuard"}},
"S1037": {{Dir: "CheckElaborateSleep"}},
"S1038": {{Dir: "CheckPrintSprintf"}},
"S1039": {{Dir: "CheckSprintLiteral"}},
"S1040": {{Dir: "CheckSameTypeTypeAssertion"}},
}
testutil.Run(t, Analyzers, checks)
}
go-tools-2021.1.2/simple/testdata/ 0000775 0000000 0000000 00000000000 14143223131 0016576 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/ 0000775 0000000 0000000 00000000000 14143223131 0017365 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckAssertNotNil/ 0000775 0000000 0000000 00000000000 14143223131 0022710 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckAssertNotNil/LintAssertNotNil.go 0000664 0000000 0000000 00000001763 14143223131 0026462 0 ustar 00root root 0000000 0000000 package pkg
func fn(i interface{}, x interface{}) {
if _, ok := i.(string); ok && i != nil { // want `when ok is true, i can't be nil`
}
if _, ok := i.(string); i != nil && ok { // want `when ok is true, i can't be nil`
}
if _, ok := i.(string); i != nil || ok {
}
if _, ok := i.(string); i != nil && !ok {
}
if _, ok := i.(string); i == nil && ok {
}
if i != nil {
if _, ok := i.(string); ok { // want `when ok is true, i can't be nil`
}
}
if i != nil {
// This gets flagged because of https://github.com/dominikh/go-tools/issues/1047
if _, ok := i.(string); ok { // want `when ok is true, i can't be nil`
} else {
//
}
}
if i != nil {
if _, ok := i.(string); ok {
} else {
println()
}
}
if i != nil {
if _, ok := i.(string); ok {
}
println(i)
}
if i == nil {
if _, ok := i.(string); ok {
}
}
if i != nil {
if _, ok := i.(string); !ok {
}
}
if x != nil {
if _, ok := i.(string); ok {
}
}
if i != nil {
if _, ok := x.(string); ok {
}
}
}
go-tools-2021.1.2/simple/testdata/src/CheckBlankOK/ 0000775 0000000 0000000 00000000000 14143223131 0021604 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckBlankOK/LintBlankOK.go 0000664 0000000 0000000 00000000375 14143223131 0024250 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var m map[int]int
var ch chan int
var fn func() (int, bool)
x, _ := m[0] // want `unnecessary assignment to the blank identifier`
x, _ = <-ch // want `unnecessary assignment to the blank identifier`
x, _ = fn()
_ = x
}
go-tools-2021.1.2/simple/testdata/src/CheckBlankOK/LintBlankOK.go.golden 0000664 0000000 0000000 00000000367 14143223131 0025520 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var m map[int]int
var ch chan int
var fn func() (int, bool)
x := m[0] // want `unnecessary assignment to the blank identifier`
x = <-ch // want `unnecessary assignment to the blank identifier`
x, _ = fn()
_ = x
}
go-tools-2021.1.2/simple/testdata/src/CheckBytesBufferConversions/ 0000775 0000000 0000000 00000000000 14143223131 0024774 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckBytesBufferConversions/LintBytesBufferConversions.go 0000664 0000000 0000000 00000001400 14143223131 0032616 0 ustar 00root root 0000000 0000000 package pkg
import (
"bytes"
)
func fn() {
buf := bytes.NewBufferString("str")
_ = string(buf.Bytes()) // want `should use buf\.String\(\) instead of string\(buf\.Bytes\(\)\)`
_ = []byte(buf.String()) // want `should use buf\.Bytes\(\) instead of \[\]byte\(buf\.String\(\)\)`
m := map[string]*bytes.Buffer{"key": buf}
_ = string(m["key"].Bytes()) // want `should use m\["key"\]\.String\(\) instead of string\(m\["key"\]\.Bytes\(\)\)`
_ = []byte(m["key"].String()) // want `should use m\["key"\]\.Bytes\(\) instead of \[\]byte\(m\["key"\]\.String\(\)\)`
var m2 map[string]int
_ = m2[string(buf.Bytes())] // no warning, this is more efficient than buf.String()
string := func(_ interface{}) interface{} {
return nil
}
_ = string(m["key"].Bytes())
}
LintBytesBufferConversions.go.golden 0000664 0000000 0000000 00000001340 14143223131 0034011 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckBytesBufferConversions package pkg
import (
"bytes"
)
func fn() {
buf := bytes.NewBufferString("str")
_ = buf.String() // want `should use buf\.String\(\) instead of string\(buf\.Bytes\(\)\)`
_ = buf.Bytes() // want `should use buf\.Bytes\(\) instead of \[\]byte\(buf\.String\(\)\)`
m := map[string]*bytes.Buffer{"key": buf}
_ = m["key"].String() // want `should use m\["key"\]\.String\(\) instead of string\(m\["key"\]\.Bytes\(\)\)`
_ = m["key"].Bytes() // want `should use m\["key"\]\.Bytes\(\) instead of \[\]byte\(m\["key"\]\.String\(\)\)`
var m2 map[string]int
_ = m2[string(buf.Bytes())] // no warning, this is more efficient than buf.String()
string := func(_ interface{}) interface{} {
return nil
}
_ = string(m["key"].Bytes())
}
go-tools-2021.1.2/simple/testdata/src/CheckDeclareAssign/ 0000775 0000000 0000000 00000000000 14143223131 0023027 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckDeclareAssign/LintDeclareAssign.go 0000664 0000000 0000000 00000001004 14143223131 0026704 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var x int // want `should merge variable declaration with assignment on next line`
x = 1
_ = x
var y interface{} // want `should merge variable declaration with assignment on next line`
y = 1
_ = y
if true {
var x string // want `should merge variable declaration with assignment on next line`
x = ""
_ = x
}
var z []string
z = append(z, "")
_ = z
var f func()
f = func() { f() }
_ = f
var a int
a = 1
a = 2
_ = a
var b int
b = 1
// do stuff
b = 2
_ = b
}
go-tools-2021.1.2/simple/testdata/src/CheckDeclareAssign/LintDeclareAssign.go.golden 0000664 0000000 0000000 00000000437 14143223131 0030164 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var x int = 1
_ = x
var y interface{} = 1
_ = y
if true {
var x string = ""
_ = x
}
var z []string
z = append(z, "")
_ = z
var f func()
f = func() { f() }
_ = f
var a int
a = 1
a = 2
_ = a
var b int
b = 1
// do stuff
b = 2
_ = b
}
go-tools-2021.1.2/simple/testdata/src/CheckElaborateSleep/ 0000775 0000000 0000000 00000000000 14143223131 0023212 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckElaborateSleep/LintElaborateSleep.go 0000664 0000000 0000000 00000000570 14143223131 0027261 0 ustar 00root root 0000000 0000000 package pkg
import (
"fmt"
"time"
)
func fn() {
time.Sleep(0)
select { // want `should use time.Sleep`
case <-time.After(0):
}
select { // want `should use time.Sleep`
case <-time.After(0):
fmt.Println("yay")
}
const d = 0
select { // want `should use time.Sleep`
case <-time.After(d):
}
var ch chan int
select {
case <-time.After(0):
case <-ch:
}
}
go-tools-2021.1.2/simple/testdata/src/CheckElaborateSleep/LintElaborateSleep.go.golden 0000664 0000000 0000000 00000000416 14143223131 0030527 0 ustar 00root root 0000000 0000000 package pkg
import (
"fmt"
"time"
)
func fn() {
time.Sleep(0)
time.Sleep(0)
select { // want `should use time.Sleep`
case <-time.After(0):
fmt.Println("yay")
}
const d = 0
time.Sleep(d)
var ch chan int
select {
case <-time.After(0):
case <-ch:
}
}
go-tools-2021.1.2/simple/testdata/src/CheckErrorsNewSprintf/ 0000775 0000000 0000000 00000000000 14143223131 0023617 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckErrorsNewSprintf/LintErrorsNewSprintf.go 0000664 0000000 0000000 00000000254 14143223131 0030272 0 ustar 00root root 0000000 0000000 package pkg
import (
"errors"
"fmt"
)
func fn() {
_ = fmt.Errorf("%d", 0)
_ = errors.New("")
_ = errors.New(fmt.Sprintf("%d", 0)) // want `should use fmt\.Errorf`
}
go-tools-2021.1.2/simple/testdata/src/CheckErrorsNewSprintf/LintErrorsNewSprintf.go.golden 0000664 0000000 0000000 00000000237 14143223131 0031542 0 ustar 00root root 0000000 0000000 package pkg
import (
"errors"
"fmt"
)
func fn() {
_ = fmt.Errorf("%d", 0)
_ = errors.New("")
_ = fmt.Errorf("%d", 0) // want `should use fmt\.Errorf`
}
go-tools-2021.1.2/simple/testdata/src/CheckGuardedDelete/ 0000775 0000000 0000000 00000000000 14143223131 0023021 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckGuardedDelete/LintGuardedDelete.go 0000664 0000000 0000000 00000001236 14143223131 0026677 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
func fn(m map[int]int) {
if _, ok := m[0]; ok { // want `unnecessary guard`
delete(m, 0)
}
if _, ok := m[0]; !ok {
delete(m, 0)
}
if _, ok := m[0]; ok {
println("deleting")
delete(m, 0)
}
if v, ok := m[0]; ok && v > 0 {
delete(m, 0)
}
var key int
if _, ok := m[key]; ok { // want `unnecessary guard`
delete(m, key)
}
if _, ok := m[key]; ok {
delete(m, 0)
}
if _, ok := m[key]; ok {
delete(m, key)
} else {
println("not deleted")
}
var ok bool
if _, ok = m[key]; ok {
delete(m, 0)
}
if ok {
println("deleted")
}
delete := func(a, b interface{}) {}
if _, ok := m[0]; ok {
delete(m, 0)
}
}
go-tools-2021.1.2/simple/testdata/src/CheckGuardedDelete/LintGuardedDelete.go.golden 0000664 0000000 0000000 00000001054 14143223131 0030144 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
func fn(m map[int]int) {
delete(m, 0)
if _, ok := m[0]; !ok {
delete(m, 0)
}
if _, ok := m[0]; ok {
println("deleting")
delete(m, 0)
}
if v, ok := m[0]; ok && v > 0 {
delete(m, 0)
}
var key int
delete(m, key)
if _, ok := m[key]; ok {
delete(m, 0)
}
if _, ok := m[key]; ok {
delete(m, key)
} else {
println("not deleted")
}
var ok bool
if _, ok = m[key]; ok {
delete(m, 0)
}
if ok {
println("deleted")
}
delete := func(a, b interface{}) {}
if _, ok := m[0]; ok {
delete(m, 0)
}
}
go-tools-2021.1.2/simple/testdata/src/CheckLoopSlide/ 0000775 0000000 0000000 00000000000 14143223131 0022215 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckLoopSlide/LintLoopSlide.go 0000664 0000000 0000000 00000000630 14143223131 0025264 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var n int
var bs []int
var offset int
for i := 0; i < n; i++ { // want `should use copy\(\) instead of loop for sliding slice elements`
bs[i] = bs[offset+i]
}
for i := 1; i < n; i++ { // not currently supported
bs[i] = bs[offset+i]
}
for i := 1; i < n; i++ { // not currently supported
bs[i] = bs[i+offset]
}
for i := 0; i <= n; i++ {
bs[i] = bs[offset+i]
}
}
go-tools-2021.1.2/simple/testdata/src/CheckLoopSlide/LintLoopSlide.go.golden 0000664 0000000 0000000 00000000466 14143223131 0026542 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var n int
var bs []int
var offset int
copy(bs[:n], bs[offset:])
for i := 1; i < n; i++ { // not currently supported
bs[i] = bs[offset+i]
}
for i := 1; i < n; i++ { // not currently supported
bs[i] = bs[i+offset]
}
for i := 0; i <= n; i++ {
bs[i] = bs[offset+i]
}
}
go-tools-2021.1.2/simple/testdata/src/CheckMakeLenCap/ 0000775 0000000 0000000 00000000000 14143223131 0022263 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckMakeLenCap/LintMakeLenCap.go 0000664 0000000 0000000 00000001304 14143223131 0025377 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
const c = 0
var x, y int
type s []int
type ch chan int
_ = make([]int, 1)
_ = make([]int, 0) // length is mandatory for slices, don't suggest removal
_ = make(s, 0) // length is mandatory for slices, don't suggest removal
_ = make(chan int, c) // constant of 0 may be due to debugging, math or platform-specific code
_ = make(chan int, 0) // want `should use make\(chan int\) instead`
_ = make(ch, 0) // want `should use make\(ch\) instead`
_ = make(map[int]int, 0)
_ = make([]int, 1, 1) // want `should use make\(\[\]int, 1\) instead`
_ = make([]int, x, x) // want `should use make\(\[\]int, x\) instead`
_ = make([]int, 1, 2)
_ = make([]int, x, y)
}
go-tools-2021.1.2/simple/testdata/src/CheckNilCheckAroundRange/ 0000775 0000000 0000000 00000000000 14143223131 0024131 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckNilCheckAroundRange/LintNilCheckAroundRange.go 0000664 0000000 0000000 00000001344 14143223131 0031117 0 ustar 00root root 0000000 0000000 package pkg
import "fmt"
func main() {
str := []string{}
// range outside nil check should not match
for _, s := range str {
s = s + "B"
}
// body with multiple statements should not match
if str != nil {
str = append(str, "C")
for _, s := range str {
s = s + "D"
}
}
if str != nil { // want `unnecessary nil check around range`
for _, s := range str {
s = s + "A"
}
}
var nilMap map[string]int
if nilMap != nil { // want `unnecessary nil check around range`
for key, value := range nilMap {
nilMap[key] = value + 1
}
}
// range over channel can have nil check, as it is required to avoid blocking
var nilChan chan int
if nilChan != nil {
for v := range nilChan {
fmt.Println(v)
}
}
}
go-tools-2021.1.2/simple/testdata/src/CheckPrintSprintf/ 0000775 0000000 0000000 00000000000 14143223131 0022765 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckPrintSprintf/CheckPrintSprintf.go 0000664 0000000 0000000 00000001035 14143223131 0026713 0 ustar 00root root 0000000 0000000 package pkg
import "fmt"
func fn() {
fmt.Print(fmt.Sprintf("%d", 1)) // want `should use fmt\.Printf`
fmt.Println(fmt.Sprintf("%d", 1)) // want `don't forget the newline`
fmt.Fprint(nil, fmt.Sprintf("%d", 1)) // want `should use fmt\.Fprintf`
fmt.Fprintln(nil, fmt.Sprintf("%d", 1)) // want `don't forget the newline`
fmt.Sprint(fmt.Sprintf("%d", 1)) // want `should use fmt\.Sprintf`
fmt.Sprintln(fmt.Sprintf("%d", 1)) // want `don't forget the newline`
arg := "%d"
fmt.Println(fmt.Sprintf(arg, 1))
}
go-tools-2021.1.2/simple/testdata/src/CheckRangeStringRunes/ 0000775 0000000 0000000 00000000000 14143223131 0023563 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckRangeStringRunes/LintRangeStringRunes.go 0000664 0000000 0000000 00000000757 14143223131 0030212 0 ustar 00root root 0000000 0000000 package pkg
type String string
func fn(s string, s2 String) {
for _, r := range s {
println(r)
}
for _, r := range []rune(s) { // want `should range over string`
println(r)
}
for i, r := range []rune(s) {
println(i)
println(r)
}
x := []rune(s)
for _, r := range x { // want `should range over string`
println(r)
}
y := []rune(s)
for _, r := range y {
println(r)
}
println(y[0])
for _, r := range []rune(s2) { // want `should range over string`
println(r)
}
}
go-tools-2021.1.2/simple/testdata/src/CheckRedundantBreak/ 0000775 0000000 0000000 00000000000 14143223131 0023214 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckRedundantBreak/LintRedundantBreak.go 0000664 0000000 0000000 00000000665 14143223131 0027272 0 ustar 00root root 0000000 0000000 package pkg
func fn(x int) {
switch x {
case 1:
println()
break // want `redundant break`
case 2:
println()
case 3:
break // don't flag cases only consisting of break
case 4:
println()
break
println()
case 5:
println()
if true {
break // we don't currently detect this
}
case 6:
println()
if true {
break
}
println()
}
label:
for {
switch x {
case 1:
println()
break label
}
}
}
go-tools-2021.1.2/simple/testdata/src/CheckRedundantCanonicalHeaderKey/ 0000775 0000000 0000000 00000000000 14143223131 0025641 5 ustar 00root root 0000000 0000000 LintRedundantCanonicalHeaderKey.go 0000664 0000000 0000000 00000002445 14143223131 0034263 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckRedundantCanonicalHeaderKey package pkg
import (
"net/http"
"strings"
)
func fn1() {
var headers http.Header
// Matches
headers.Add(http.CanonicalHeaderKey("test"), "test") // want `calling net/http.CanonicalHeaderKey on the 'key' argument of`
headers.Del(http.CanonicalHeaderKey("test")) // want `calling net/http.CanonicalHeaderKey on the 'key' argument of`
headers.Get(http.CanonicalHeaderKey("test")) // want `calling net/http.CanonicalHeaderKey on the 'key' argument of`
headers.Set(http.CanonicalHeaderKey("test"), "test") // want `calling net/http.CanonicalHeaderKey on the 'key' argument of`
// Non-matches
headers.Add("test", "test")
headers.Del("test")
headers.Get("test")
headers.Set("test", "test")
headers.Add("test", http.CanonicalHeaderKey("test"))
headers.Set("test", http.CanonicalHeaderKey("test"))
headers.Add(http.CanonicalHeaderKey("test")+"1", "test")
headers.Del(http.CanonicalHeaderKey("test") + "1")
headers.Get(http.CanonicalHeaderKey("test") + "1")
headers.Set(http.CanonicalHeaderKey("test")+"1", "test")
headers.Add(strings.ToUpper(http.CanonicalHeaderKey("test")), "test")
headers.Del(strings.ToUpper(http.CanonicalHeaderKey("test")))
headers.Get(strings.ToUpper(http.CanonicalHeaderKey("test")))
headers.Set(strings.ToUpper(http.CanonicalHeaderKey("test")), "test")
}
LintRedundantCanonicalHeaderKey.go.golden 0000664 0000000 0000000 00000002301 14143223131 0035521 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckRedundantCanonicalHeaderKey package pkg
import (
"net/http"
"strings"
)
func fn1() {
var headers http.Header
// Matches
headers.Add("test", "test") // want `calling net/http.CanonicalHeaderKey on the 'key' argument of`
headers.Del("test") // want `calling net/http.CanonicalHeaderKey on the 'key' argument of`
headers.Get("test") // want `calling net/http.CanonicalHeaderKey on the 'key' argument of`
headers.Set("test", "test") // want `calling net/http.CanonicalHeaderKey on the 'key' argument of`
// Non-matches
headers.Add("test", "test")
headers.Del("test")
headers.Get("test")
headers.Set("test", "test")
headers.Add("test", http.CanonicalHeaderKey("test"))
headers.Set("test", http.CanonicalHeaderKey("test"))
headers.Add(http.CanonicalHeaderKey("test")+"1", "test")
headers.Del(http.CanonicalHeaderKey("test") + "1")
headers.Get(http.CanonicalHeaderKey("test") + "1")
headers.Set(http.CanonicalHeaderKey("test")+"1", "test")
headers.Add(strings.ToUpper(http.CanonicalHeaderKey("test")), "test")
headers.Del(strings.ToUpper(http.CanonicalHeaderKey("test")))
headers.Get(strings.ToUpper(http.CanonicalHeaderKey("test")))
headers.Set(strings.ToUpper(http.CanonicalHeaderKey("test")), "test")
}
go-tools-2021.1.2/simple/testdata/src/CheckRedundantReturn/ 0000775 0000000 0000000 00000000000 14143223131 0023447 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckRedundantReturn/LintRedundantReturn.go 0000664 0000000 0000000 00000000627 14143223131 0027756 0 ustar 00root root 0000000 0000000 package pkg
func fn1() {
return // want `redundant return`
}
func fn2(a int) {
return // want `redundant return`
}
func fn3() int {
return 3
}
func fn4() (n int) {
return
}
func fn5(b bool) {
if b {
return
}
}
func fn6() {
return
println("foo")
}
func fn7() {
return
println("foo")
return // want `redundant return`
}
func fn8() {
_ = func() {
return // want `redundant return`
}
}
go-tools-2021.1.2/simple/testdata/src/CheckRedundantSprintf/ 0000775 0000000 0000000 00000000000 14143223131 0023615 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckRedundantSprintf/LintRedundantSprintf.go 0000664 0000000 0000000 00000002701 14143223131 0030265 0 ustar 00root root 0000000 0000000 package pkg
import "fmt"
type T1 string
type T2 T1
type T3 int
type T4 int
type T5 int
type T6 string
type T7 []byte
type T8 []MyByte
type T9 string
type T10 []byte
type T11 int
type MyByte byte
func (T3) String() string { return "" }
func (T6) String() string { return "" }
func (T4) String(arg int) string { return "" }
func (T5) String() {}
func (T9) Format(f fmt.State, c rune) {}
func (T10) Format(f fmt.State, c rune) {}
func (T11) Format(f fmt.State, c rune) {}
func (T11) String() string { return "" }
func fn() {
var t1 T1
var t2 T2
var t3 T3
var t4 T4
var t5 T5
var t6 T6
var t7 T7
var t8 T8
var t9 T9
var t10 T10
var t11 T11
_ = fmt.Sprintf("%s", "test") // want `is already a string`
_ = fmt.Sprintf("%s", t1) // want `is a string`
_ = fmt.Sprintf("%s", t2) // want `is a string`
_ = fmt.Sprintf("%s", t3) // want `should use String\(\) instead of fmt\.Sprintf`
_ = fmt.Sprintf("%s", t3.String()) // want `is already a string`
_ = fmt.Sprintf("%s", t4)
_ = fmt.Sprintf("%s", t5)
_ = fmt.Sprintf("%s %s", t1, t2)
_ = fmt.Sprintf("%v", t1)
_ = fmt.Sprintf("%s", t6) // want `should use String\(\) instead of fmt\.Sprintf`
_ = fmt.Sprintf("%s", t7) // want `underlying type is a slice of bytes`
_ = fmt.Sprintf("%s", t8)
// don't simplify types that implement fmt.Formatter
_ = fmt.Sprintf("%s", t9)
_ = fmt.Sprintf("%s", t10)
_ = fmt.Sprintf("%s", t11)
}
go-tools-2021.1.2/simple/testdata/src/CheckRedundantSprintf/LintRedundantSprintf.go.golden 0000664 0000000 0000000 00000002516 14143223131 0031540 0 ustar 00root root 0000000 0000000 package pkg
import "fmt"
type T1 string
type T2 T1
type T3 int
type T4 int
type T5 int
type T6 string
type T7 []byte
type T8 []MyByte
type T9 string
type T10 []byte
type T11 int
type MyByte byte
func (T3) String() string { return "" }
func (T6) String() string { return "" }
func (T4) String(arg int) string { return "" }
func (T5) String() {}
func (T9) Format(f fmt.State, c rune) {}
func (T10) Format(f fmt.State, c rune) {}
func (T11) Format(f fmt.State, c rune) {}
func (T11) String() string { return "" }
func fn() {
var t1 T1
var t2 T2
var t3 T3
var t4 T4
var t5 T5
var t6 T6
var t7 T7
var t8 T8
var t9 T9
var t10 T10
var t11 T11
_ = "test" // want `is already a string`
_ = string(t1) // want `is a string`
_ = string(t2) // want `is a string`
_ = t3.String() // want `should use String\(\) instead of fmt\.Sprintf`
_ = t3.String() // want `is already a string`
_ = fmt.Sprintf("%s", t4)
_ = fmt.Sprintf("%s", t5)
_ = fmt.Sprintf("%s %s", t1, t2)
_ = fmt.Sprintf("%v", t1)
_ = t6.String() // want `should use String\(\) instead of fmt\.Sprintf`
_ = string(t7) // want `underlying type is a slice of bytes`
_ = fmt.Sprintf("%s", t8)
// don't simplify types that implement fmt.Formatter
_ = fmt.Sprintf("%s", t9)
_ = fmt.Sprintf("%s", t10)
_ = fmt.Sprintf("%s", t11)
}
go-tools-2021.1.2/simple/testdata/src/CheckSameTypeTypeAssertion/ 0000775 0000000 0000000 00000000000 14143223131 0024604 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckSameTypeTypeAssertion/CheckSameTypeTypeAssertion.go 0000664 0000000 0000000 00000003051 14143223131 0032351 0 ustar 00root root 0000000 0000000 package pkg
type SomeInterface interface {
Foo()
}
func fn(x SomeInterface) {
_ = x.(SomeInterface) // want `type assertion to the same type: x already has type SomeInterface`
y := x.(SomeInterface) // want `type assertion to the same type`
y = x.(SomeInterface) // want `type assertion to the same type`
var a SomeInterface = x.(SomeInterface) // want `type assertion to the same type`
z, _ := x.(SomeInterface) // want `type assertion to the same type`
z, _ = x.(SomeInterface) // want `type assertion to the same type`
_, ok := x.(SomeInterface) // want `type assertion to the same type`
_, ok = x.(SomeInterface) // want `type assertion to the same type`
_, _ = x.(SomeInterface) // want `type assertion to the same type`
if z, ok := x.(SomeInterface); ok { // want `type assertion to the same type`
_ = z
}
if _, ok := x.(SomeInterface); !ok { // want `type assertion to the same type`
}
if _, ok = x.(SomeInterface); !ok { // want `type assertion to the same type`
}
if z, ok = x.(SomeInterface); ok { // want `type assertion to the same type`
}
if z := x.(SomeInterface); true { // want `type assertion to the same type`
_ = z
}
if z, _ := x.(SomeInterface); true { // want `type assertion to the same type`
_ = z
}
if _, _ = x.(SomeInterface); true { // want `type assertion to the same type`
}
if _ = x.(SomeInterface); true { // want `type assertion to the same type`
}
switch x.(type) {
case SomeInterface:
}
_ = a
_ = y
_ = ok
_ = z
}
go-tools-2021.1.2/simple/testdata/src/CheckSimplifyTypeSwitch/ 0000775 0000000 0000000 00000000000 14143223131 0024143 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckSimplifyTypeSwitch/LintSimplifyTypeSwitch.go 0000664 0000000 0000000 00000001013 14143223131 0031134 0 ustar 00root root 0000000 0000000 package pkg
import "fmt"
func gen() interface{} { return nil }
func fn(x, y interface{}) {
switch z := x.(type) {
case int:
_ = z
fmt.Println(x.(int))
}
switch x.(type) {
case int:
fmt.Println(x.(int), y.(int))
}
switch x.(type) { // want `assigning the result of this type assertion`
case int:
fmt.Println(x.(int))
}
switch x.(type) {
case int:
fmt.Println(x.(string))
}
switch x.(type) {
case int:
fmt.Println(y.(int))
}
switch (gen()).(type) {
case int:
fmt.Println((gen()).(int))
}
}
go-tools-2021.1.2/simple/testdata/src/CheckSimplifyTypeSwitch/LintSimplifyTypeSwitch.go.golden 0000664 0000000 0000000 00000001012 14143223131 0032402 0 ustar 00root root 0000000 0000000 package pkg
import "fmt"
func gen() interface{} { return nil }
func fn(x, y interface{}) {
switch z := x.(type) {
case int:
_ = z
fmt.Println(x.(int))
}
switch x.(type) {
case int:
fmt.Println(x.(int), y.(int))
}
switch x := x.(type) { // want `assigning the result of this type assertion`
case int:
fmt.Println(x)
}
switch x.(type) {
case int:
fmt.Println(x.(string))
}
switch x.(type) {
case int:
fmt.Println(y.(int))
}
switch (gen()).(type) {
case int:
fmt.Println((gen()).(int))
}
}
go-tools-2021.1.2/simple/testdata/src/CheckSortHelpers/ 0000775 0000000 0000000 00000000000 14143223131 0022575 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckSortHelpers/LintSortHelpers.go 0000664 0000000 0000000 00000002127 14143223131 0026227 0 ustar 00root root 0000000 0000000 package pkg
import "sort"
type MyIntSlice []int
func (s MyIntSlice) Len() int { return 0 }
func (s MyIntSlice) Less(i, j int) bool { return true }
func (s MyIntSlice) Swap(i, j int) {}
func fn1() {
var a []int
sort.Sort(sort.IntSlice(a)) // want `sort\.Ints`
}
func fn2() {
var b []float64
sort.Sort(sort.Float64Slice(b)) // want `sort\.Float64s`
}
func fn3() {
var c []string
sort.Sort(sort.StringSlice(c)) // want `sort\.Strings`
}
func fn4() {
var a []int
sort.Sort(MyIntSlice(a))
}
func fn5() {
var d MyIntSlice
sort.Sort(d)
}
func fn6() {
var e sort.Interface
sort.Sort(e)
}
func fn7() {
// Don't recommend sort.Ints when there was another legitimate
// sort.Sort call already
var a []int
var e sort.Interface
sort.Sort(e)
sort.Sort(sort.IntSlice(a))
}
func fn8() {
var a []int
sort.Sort(sort.IntSlice(a)) // want `sort\.Ints`
sort.Sort(sort.IntSlice(a)) // want `sort\.Ints`
}
func fn9() {
func() {
var a []int
sort.Sort(sort.IntSlice(a)) // want `sort\.Ints`
}()
}
func fn10() {
var a MyIntSlice
sort.Sort(sort.IntSlice(a)) // want `sort\.Ints`
}
go-tools-2021.1.2/simple/testdata/src/CheckSprintLiteral/ 0000775 0000000 0000000 00000000000 14143223131 0023117 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckSprintLiteral/CheckSprintLiteral.go 0000664 0000000 0000000 00000000407 14143223131 0027201 0 ustar 00root root 0000000 0000000 package pkg
import "fmt"
func fn() {
_ = fmt.Sprint("foo") // want `unnecessary use of fmt\.Sprint`
_ = fmt.Sprintf("foo") // want `unnecessary use of fmt\.Sprintf`
_ = fmt.Sprintf("foo %d")
_ = fmt.Sprintf("foo %d", 1)
var x string
_ = fmt.Sprint(x)
}
go-tools-2021.1.2/simple/testdata/src/CheckSprintLiteral/CheckSprintLiteral.go.golden 0000664 0000000 0000000 00000000355 14143223131 0030452 0 ustar 00root root 0000000 0000000 package pkg
import "fmt"
func fn() {
_ = "foo" // want `unnecessary use of fmt\.Sprint`
_ = "foo" // want `unnecessary use of fmt\.Sprintf`
_ = fmt.Sprintf("foo %d")
_ = fmt.Sprintf("foo %d", 1)
var x string
_ = fmt.Sprint(x)
}
go-tools-2021.1.2/simple/testdata/src/CheckTimeUntil_go17/ 0000775 0000000 0000000 00000000000 14143223131 0023072 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckTimeUntil_go17/LimeTimeUntil_go17.go 0000664 0000000 0000000 00000000110 14143223131 0026767 0 ustar 00root root 0000000 0000000 package pkg
import "time"
func fn(t time.Time) {
t.Sub(time.Now())
}
go-tools-2021.1.2/simple/testdata/src/CheckTimeUntil_go18/ 0000775 0000000 0000000 00000000000 14143223131 0023073 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckTimeUntil_go18/LimeTimeUntil_go18.go 0000664 0000000 0000000 00000000205 14143223131 0026776 0 ustar 00root root 0000000 0000000 package pkg
import "time"
func fn(t time.Time) {
t.Sub(time.Now()) // want `time\.Until`
t.Sub(t)
t2 := time.Now()
t.Sub(t2)
}
go-tools-2021.1.2/simple/testdata/src/CheckTimeUntil_go18/LimeTimeUntil_go18.go.golden 0000664 0000000 0000000 00000000201 14143223131 0030241 0 ustar 00root root 0000000 0000000 package pkg
import "time"
func fn(t time.Time) {
time.Until(t) // want `time\.Until`
t.Sub(t)
t2 := time.Now()
t.Sub(t2)
}
go-tools-2021.1.2/simple/testdata/src/CheckUnnecessaryGuard/ 0000775 0000000 0000000 00000000000 14143223131 0023605 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/CheckUnnecessaryGuard/LintUnnecessaryGuard.go 0000664 0000000 0000000 00000002472 14143223131 0030252 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var m = map[string][]string{}
if _, ok := m["k1"]; ok { // want `unnecessary guard around map access`
m["k1"] = append(m["k1"], "v1", "v2")
} else {
m["k1"] = []string{"v1", "v2"}
}
if _, ok := m["k1"]; ok {
m["k1"] = append(m["k1"], "v1", "v2")
} else {
m["k1"] = []string{"v1"}
}
if _, ok := m["k1"]; ok {
m["k2"] = append(m["k2"], "v1")
} else {
m["k1"] = []string{"v1"}
}
k1 := "key"
if _, ok := m[k1]; ok { // want `unnecessary guard around map access`
m[k1] = append(m[k1], "v1", "v2")
} else {
m[k1] = []string{"v1", "v2"}
}
// ellipsis is not currently supported
v := []string{"v1", "v2"}
if _, ok := m["k1"]; ok {
m["k1"] = append(m["k1"], v...)
} else {
m["k1"] = v
}
var m2 map[string]int
if _, ok := m2["k"]; ok { // want `unnecessary guard around map access`
m2["k"] += 4
} else {
m2["k"] = 4
}
if _, ok := m2["k"]; ok {
m2["k"] += 4
} else {
m2["k"] = 3
}
if _, ok := m2["k"]; ok { // want `unnecessary guard around map access`
m2["k"]++
} else {
m2["k"] = 1
}
if _, ok := m2["k"]; ok {
m2["k"] -= 1
} else {
m2["k"] = 1
}
}
// this used to cause a panic in the pattern package
func fn2() {
var obj interface{}
if _, ok := obj.(map[string]interface{})["items"]; ok {
obj.(map[string]interface{})["version"] = 1
}
}
go-tools-2021.1.2/simple/testdata/src/CheckUnnecessaryGuard/LintUnnecessaryGuard.go.golden 0000664 0000000 0000000 00000001604 14143223131 0031515 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var m = map[string][]string{}
m["k1"] = append(m["k1"], "v1", "v2")
if _, ok := m["k1"]; ok {
m["k1"] = append(m["k1"], "v1", "v2")
} else {
m["k1"] = []string{"v1"}
}
if _, ok := m["k1"]; ok {
m["k2"] = append(m["k2"], "v1")
} else {
m["k1"] = []string{"v1"}
}
k1 := "key"
m[k1] = append(m[k1], "v1", "v2")
// ellipsis is not currently supported
v := []string{"v1", "v2"}
if _, ok := m["k1"]; ok {
m["k1"] = append(m["k1"], v...)
} else {
m["k1"] = v
}
var m2 map[string]int
m2["k"] += 4
if _, ok := m2["k"]; ok {
m2["k"] += 4
} else {
m2["k"] = 3
}
m2["k"]++
if _, ok := m2["k"]; ok {
m2["k"] -= 1
} else {
m2["k"] = 1
}
}
// this used to cause a panic in the pattern package
func fn2() {
var obj interface{}
if _, ok := obj.(map[string]interface{})["items"]; ok {
obj.(map[string]interface{})["version"] = 1
}
}
go-tools-2021.1.2/simple/testdata/src/bool-cmp/ 0000775 0000000 0000000 00000000000 14143223131 0021075 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/bool-cmp/bool-cmp.go 0000664 0000000 0000000 00000002324 14143223131 0023135 0 ustar 00root root 0000000 0000000 package pkg
func fn1() bool { return false }
func fn2() bool { return false }
func fn() {
type T bool
var x T
const t T = false
if x == t {
}
if fn1() == true { // want `simplified to fn1\(\)`
}
if fn1() != true { // want `simplified to !fn1\(\)`
}
if fn1() == false { // want `simplified to !fn1\(\)`
}
if fn1() != false { // want `simplified to fn1\(\)`
}
if fn1() && (fn1() || fn1()) || (fn1() && fn1()) == true { // want `simplified to \(fn1\(\) && fn1\(\)\)`
}
if (fn1() && fn2()) == false { // want `simplified to !\(fn1\(\) && fn2\(\)\)`
}
var y bool
for y != true { // want `simplified to !y`
}
if !y == true { // want `simplified to !y`
}
if !y == false { // want `simplified to y`
}
if !y != true { // want `simplified to y`
}
if !y != false { // want `simplified to !y`
}
if !!y == false { // want `simplified to !y`
}
if !!!y == false { // want `simplified to y`
}
if !!y == true { // want `simplified to y`
}
if !!!y == true { // want `simplified to !y`
}
if !!y != true { // want `simplified to !y`
}
if !!!y != true { // want `simplified to y`
}
if !y == !false { // not matched because we expect true/false on one side, not !false
}
var z interface{}
if z == true {
}
}
go-tools-2021.1.2/simple/testdata/src/bool-cmp/bool-cmp.go.golden 0000664 0000000 0000000 00000002073 14143223131 0024405 0 ustar 00root root 0000000 0000000 package pkg
func fn1() bool { return false }
func fn2() bool { return false }
func fn() {
type T bool
var x T
const t T = false
if x == t {
}
if fn1() { // want `simplified to fn1\(\)`
}
if !fn1() { // want `simplified to !fn1\(\)`
}
if !fn1() { // want `simplified to !fn1\(\)`
}
if fn1() { // want `simplified to fn1\(\)`
}
if fn1() && (fn1() || fn1()) || (fn1() && fn1()) { // want `simplified to \(fn1\(\) && fn1\(\)\)`
}
if !(fn1() && fn2()) { // want `simplified to !\(fn1\(\) && fn2\(\)\)`
}
var y bool
for !y { // want `simplified to !y`
}
if !y { // want `simplified to !y`
}
if y { // want `simplified to y`
}
if y { // want `simplified to y`
}
if !y { // want `simplified to !y`
}
if !y { // want `simplified to !y`
}
if y { // want `simplified to y`
}
if y { // want `simplified to y`
}
if !y { // want `simplified to !y`
}
if !y { // want `simplified to !y`
}
if y { // want `simplified to y`
}
if !y == !false { // not matched because we expect true/false on one side, not !false
}
var z interface{}
if z == true {
}
}
go-tools-2021.1.2/simple/testdata/src/bool-cmp/bool-cmp_test.go 0000664 0000000 0000000 00000000125 14143223131 0024171 0 ustar 00root root 0000000 0000000 package pkg
import "testing"
func TestFoo(t *testing.T) {
if fn1() == true {
}
}
go-tools-2021.1.2/simple/testdata/src/compare/ 0000775 0000000 0000000 00000000000 14143223131 0021013 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/compare/compare.go 0000664 0000000 0000000 00000000337 14143223131 0022773 0 ustar 00root root 0000000 0000000 package pkg
import "bytes"
func fn() {
_ = bytes.Compare(nil, nil) == 0 // want ` bytes.Equal`
_ = bytes.Compare(nil, nil) != 0 // want `!bytes.Equal`
_ = bytes.Compare(nil, nil) > 0
_ = bytes.Compare(nil, nil) < 0
}
go-tools-2021.1.2/simple/testdata/src/compare/compare.go.golden 0000664 0000000 0000000 00000000323 14143223131 0024235 0 ustar 00root root 0000000 0000000 package pkg
import "bytes"
func fn() {
_ = bytes.Equal(nil, nil) // want ` bytes.Equal`
_ = !bytes.Equal(nil, nil) // want `!bytes.Equal`
_ = bytes.Compare(nil, nil) > 0
_ = bytes.Compare(nil, nil) < 0
}
go-tools-2021.1.2/simple/testdata/src/contains/ 0000775 0000000 0000000 00000000000 14143223131 0021203 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/contains/contains.go 0000664 0000000 0000000 00000003033 14143223131 0023347 0 ustar 00root root 0000000 0000000 package pkg
import (
"bytes"
"strings"
)
func fn() {
_ = strings.IndexRune("", 'x') > -1 // want ` strings\.ContainsRune`
_ = strings.IndexRune("", 'x') >= 0 // want ` strings\.ContainsRune`
_ = strings.IndexRune("", 'x') > 0
_ = strings.IndexRune("", 'x') >= -1
_ = strings.IndexRune("", 'x') != -1 // want ` strings\.ContainsRune`
_ = strings.IndexRune("", 'x') == -1 // want `!strings\.ContainsRune`
_ = strings.IndexRune("", 'x') != 0
_ = strings.IndexRune("", 'x') < 0 // want `!strings\.ContainsRune`
_ = strings.IndexAny("", "") > -1 // want ` strings\.ContainsAny`
_ = strings.IndexAny("", "") >= 0 // want ` strings\.ContainsAny`
_ = strings.IndexAny("", "") > 0
_ = strings.IndexAny("", "") >= -1
_ = strings.IndexAny("", "") != -1 // want ` strings\.ContainsAny`
_ = strings.IndexAny("", "") == -1 // want `!strings\.ContainsAny`
_ = strings.IndexAny("", "") != 0
_ = strings.IndexAny("", "") < 0 // want `!strings\.ContainsAny`
_ = strings.Index("", "") > -1 // want ` strings\.Contains`
_ = strings.Index("", "") >= 0 // want ` strings\.Contains`
_ = strings.Index("", "") > 0
_ = strings.Index("", "") >= -1
_ = strings.Index("", "") != -1 // want ` strings\.Contains`
_ = strings.Index("", "") == -1 // want `!strings\.Contains`
_ = strings.Index("", "") != 0
_ = strings.Index("", "") < 0 // want `!strings\.Contains`
_ = bytes.IndexRune(nil, 'x') > -1 // want ` bytes\.ContainsRune`
_ = bytes.IndexAny(nil, "") > -1 // want ` bytes\.ContainsAny`
_ = bytes.Index(nil, nil) > -1 // want ` bytes\.Contains`
}
go-tools-2021.1.2/simple/testdata/src/contains/contains.go.golden 0000664 0000000 0000000 00000002775 14143223131 0024632 0 ustar 00root root 0000000 0000000 package pkg
import (
"bytes"
"strings"
)
func fn() {
_ = strings.ContainsRune("", 'x') // want ` strings\.ContainsRune`
_ = strings.ContainsRune("", 'x') // want ` strings\.ContainsRune`
_ = strings.IndexRune("", 'x') > 0
_ = strings.IndexRune("", 'x') >= -1
_ = strings.ContainsRune("", 'x') // want ` strings\.ContainsRune`
_ = !strings.ContainsRune("", 'x') // want `!strings\.ContainsRune`
_ = strings.IndexRune("", 'x') != 0
_ = !strings.ContainsRune("", 'x') // want `!strings\.ContainsRune`
_ = strings.ContainsAny("", "") // want ` strings\.ContainsAny`
_ = strings.ContainsAny("", "") // want ` strings\.ContainsAny`
_ = strings.IndexAny("", "") > 0
_ = strings.IndexAny("", "") >= -1
_ = strings.ContainsAny("", "") // want ` strings\.ContainsAny`
_ = !strings.ContainsAny("", "") // want `!strings\.ContainsAny`
_ = strings.IndexAny("", "") != 0
_ = !strings.ContainsAny("", "") // want `!strings\.ContainsAny`
_ = strings.Contains("", "") // want ` strings\.Contains`
_ = strings.Contains("", "") // want ` strings\.Contains`
_ = strings.Index("", "") > 0
_ = strings.Index("", "") >= -1
_ = strings.Contains("", "") // want ` strings\.Contains`
_ = !strings.Contains("", "") // want `!strings\.Contains`
_ = strings.Index("", "") != 0
_ = !strings.Contains("", "") // want `!strings\.Contains`
_ = bytes.ContainsRune(nil, 'x') // want ` bytes\.ContainsRune`
_ = bytes.ContainsAny(nil, "") // want ` bytes\.ContainsAny`
_ = bytes.Contains(nil, nil) // want ` bytes\.Contains`
}
go-tools-2021.1.2/simple/testdata/src/convert/ 0000775 0000000 0000000 00000000000 14143223131 0021045 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/convert/convert.go 0000664 0000000 0000000 00000000757 14143223131 0023065 0 ustar 00root root 0000000 0000000 package pkg
type t1 struct {
a int
b int
}
type t2 struct {
a int
b int
}
type t3 t1
func fn() {
v1 := t1{1, 2}
v2 := t2{1, 2}
_ = t2{v1.a, v1.b} // want `should convert v1`
_ = t2{a: v1.a, b: v1.b} // want `should convert v1`
_ = t2{b: v1.b, a: v1.a} // want `should convert v1`
_ = t3{v1.a, v1.b} // want `should convert v1`
_ = t3{v1.a, v2.b}
_ = t2{v1.b, v1.a}
_ = t2{a: v1.b, b: v1.a}
_ = t2{a: v1.a}
_ = t1{v1.a, v1.b}
v := t1{1, 2}
_ = &t2{v.a, v.b}
}
go-tools-2021.1.2/simple/testdata/src/convert/convert.go.golden 0000664 0000000 0000000 00000000667 14143223131 0024334 0 ustar 00root root 0000000 0000000 package pkg
type t1 struct {
a int
b int
}
type t2 struct {
a int
b int
}
type t3 t1
func fn() {
v1 := t1{1, 2}
v2 := t2{1, 2}
_ = t2(v1) // want `should convert v1`
_ = t2(v1) // want `should convert v1`
_ = t2(v1) // want `should convert v1`
_ = t3(v1) // want `should convert v1`
_ = t3{v1.a, v2.b}
_ = t2{v1.b, v1.a}
_ = t2{a: v1.b, b: v1.a}
_ = t2{a: v1.a}
_ = t1{v1.a, v1.b}
v := t1{1, 2}
_ = &t2{v.a, v.b}
}
go-tools-2021.1.2/simple/testdata/src/convert_go17/ 0000775 0000000 0000000 00000000000 14143223131 0021702 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/convert_go17/convert.go 0000664 0000000 0000000 00000000341 14143223131 0023707 0 ustar 00root root 0000000 0000000 package pkg
type t1 struct {
a int
b int
}
type t2 struct {
a int
b int
}
type t3 struct {
a int `tag`
b int `tag`
}
func fn() {
v1 := t1{1, 2}
_ = t2{v1.a, v1.b} // want `should convert v1`
_ = t3{v1.a, v1.b}
}
go-tools-2021.1.2/simple/testdata/src/convert_go17/convert.go.golden 0000664 0000000 0000000 00000000331 14143223131 0025155 0 ustar 00root root 0000000 0000000 package pkg
type t1 struct {
a int
b int
}
type t2 struct {
a int
b int
}
type t3 struct {
a int `tag`
b int `tag`
}
func fn() {
v1 := t1{1, 2}
_ = t2(v1) // want `should convert v1`
_ = t3{v1.a, v1.b}
}
go-tools-2021.1.2/simple/testdata/src/convert_go18/ 0000775 0000000 0000000 00000000000 14143223131 0021703 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/convert_go18/convert.go 0000664 0000000 0000000 00000000375 14143223131 0023717 0 ustar 00root root 0000000 0000000 package pkg
type t1 struct {
a int
b int
}
type t2 struct {
a int
b int
}
type t3 struct {
a int `tag`
b int `tag`
}
func fn() {
v1 := t1{1, 2}
_ = t2{v1.a, v1.b} // want `should convert v1`
_ = t3{v1.a, v1.b} // want `should convert v1`
}
go-tools-2021.1.2/simple/testdata/src/convert_go18/convert.go.golden 0000664 0000000 0000000 00000000355 14143223131 0025164 0 ustar 00root root 0000000 0000000 package pkg
type t1 struct {
a int
b int
}
type t2 struct {
a int
b int
}
type t3 struct {
a int `tag`
b int `tag`
}
func fn() {
v1 := t1{1, 2}
_ = t2(v1) // want `should convert v1`
_ = t3(v1) // want `should convert v1`
}
go-tools-2021.1.2/simple/testdata/src/copy/ 0000775 0000000 0000000 00000000000 14143223131 0020337 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/copy/copy.go 0000664 0000000 0000000 00000000651 14143223131 0021642 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var b1, b2 []byte
for i, v := range b1 { // want `should use copy`
b2[i] = v
}
for i := range b1 { // want `should use copy`
b2[i] = b1[i]
}
type T [][16]byte
var a T
b := make([]interface{}, len(a))
for i := range b {
b[i] = a[i]
}
var b3, b4 []*byte
for i := range b3 { // want `should use copy`
b4[i] = b3[i]
}
var m map[int]byte
for i, v := range b1 {
m[i] = v
}
}
go-tools-2021.1.2/simple/testdata/src/copy/copy.go.golden 0000664 0000000 0000000 00000000416 14143223131 0023110 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var b1, b2 []byte
copy(b2, b1)
copy(b2, b1)
type T [][16]byte
var a T
b := make([]interface{}, len(a))
for i := range b {
b[i] = a[i]
}
var b3, b4 []*byte
copy(b4, b3)
var m map[int]byte
for i, v := range b1 {
m[i] = v
}
}
go-tools-2021.1.2/simple/testdata/src/for-true/ 0000775 0000000 0000000 00000000000 14143223131 0021130 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/for-true/for-true.go 0000664 0000000 0000000 00000000171 14143223131 0023221 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
for false {
}
for true { // want `should use for`
}
for {
}
for i := 0; true; i++ {
}
}
go-tools-2021.1.2/simple/testdata/src/generated/ 0000775 0000000 0000000 00000000000 14143223131 0021323 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/generated/generated.go 0000664 0000000 0000000 00000000217 14143223131 0023610 0 ustar 00root root 0000000 0000000 // Code generated by a clever monkey. DO NOT EDIT.
package pkg
func fn() {
for true {
}
}
//line input.go:2
func fn2() {
for true {
}
}
go-tools-2021.1.2/simple/testdata/src/generated/input.go 0000664 0000000 0000000 00000000222 14143223131 0023005 0 ustar 00root root 0000000 0000000 package pkg
// want `should use for \{\}`
// the error is produced by generated.go, which pretends that its
// broken code came from this file.
go-tools-2021.1.2/simple/testdata/src/if-return/ 0000775 0000000 0000000 00000000000 14143223131 0021300 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/if-return/if-return.go 0000664 0000000 0000000 00000003447 14143223131 0023552 0 ustar 00root root 0000000 0000000 package pkg
func fn() bool { return true }
func fn1() bool {
x := true
if x { // want `should use 'return x'`
return true
}
return false
}
func fn2() bool {
x := true
if !x {
return true
}
if x {
return true
}
return false
}
func fn3() int {
var x bool
if x {
return 1
}
return 2
}
func fn4() bool { return true }
func fn5() bool {
if fn() { // want `should use 'return !fn\(\)'`
return false
}
return true
}
func fn6() bool {
if fn3() != fn3() { // want `should use 'return fn3\(\) != fn3\(\)'`
return true
}
return false
}
func fn7() bool {
if 1 > 2 { // want `should use 'return 1 > 2'`
return true
}
return false
}
func fn8() bool {
if fn() || fn() {
return true
}
return false
}
func fn9(x int) bool {
if x > 0 {
return true
}
return true
}
func fn10(x int) bool {
if x > 0 { // want `should use 'return x <= 0'`
return false
}
return true
}
func fn11(x bool) bool {
if x { // want `should use 'return !x'`
return false
}
return true
}
func fn12() bool {
var x []bool
if x[0] { // want `should use 'return !x\[0\]'`
return false
}
return true
}
func fn13(a, b int) bool {
if a != b { // want `should use 'return a == b' instead of 'if a != b`
return false
}
return true
}
func fn14(a, b int) bool {
if a >= b { // want `should use 'return a < b' instead of 'if a >= b`
return false
}
return true
}
func fn15() bool {
if !fn() { // want `should use 'return fn\(\)'`
return false
}
return true
}
func fn16() <-chan bool {
x := make(chan bool, 1)
x <- true
return x
}
func fn17() bool {
if <-fn16() { // want `should use 'return !<-fn16\(\)'`
return false
}
return true
}
func fn18() *bool {
x := true
return &x
}
func fn19() bool {
if *fn18() { // want `should use 'return !\*fn18\(\)'`
return false
}
return true
}
go-tools-2021.1.2/simple/testdata/src/loop-append/ 0000775 0000000 0000000 00000000000 14143223131 0021603 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/loop-append/loop-append.go 0000664 0000000 0000000 00000001666 14143223131 0024361 0 ustar 00root root 0000000 0000000 package pkg
type T struct {
F string
}
func fn1() {
var x []interface{}
var y []int
for _, v := range y {
x = append(x, v)
}
var a, b []int
for _, v := range a { // want `should replace loop`
b = append(b, v)
}
var m map[string]int
var c []int
for _, v := range m {
c = append(c, v)
}
var t []T
var m2 map[string][]T
for _, tt := range t {
m2[tt.F] = append(m2[tt.F], tt)
}
var out []T
for _, tt := range t {
out = append(m2[tt.F], tt)
}
_ = out
}
func fn2() {
var v struct {
V int
}
var in []int
var out []int
for _, v.V = range in {
out = append(out, v.V)
}
}
func fn3() {
var t []T
var out [][]T
var m2 map[string][]T
for _, tt := range t {
out = append(out, m2[tt.F])
}
}
func fn4() {
var a, b, c []int
for _, v := range a {
b = append(c, v)
}
_ = b
}
func fn5() {
var t []T
var m2 map[string][]T
var out []T
for _, tt := range t {
out = append(m2[tt.F], tt)
}
_ = out
}
go-tools-2021.1.2/simple/testdata/src/loop-append/loop-append.go.golden 0000664 0000000 0000000 00000001600 14143223131 0025614 0 ustar 00root root 0000000 0000000 package pkg
type T struct {
F string
}
func fn1() {
var x []interface{}
var y []int
for _, v := range y {
x = append(x, v)
}
var a, b []int
b = append(b, a...)
var m map[string]int
var c []int
for _, v := range m {
c = append(c, v)
}
var t []T
var m2 map[string][]T
for _, tt := range t {
m2[tt.F] = append(m2[tt.F], tt)
}
var out []T
for _, tt := range t {
out = append(m2[tt.F], tt)
}
_ = out
}
func fn2() {
var v struct {
V int
}
var in []int
var out []int
for _, v.V = range in {
out = append(out, v.V)
}
}
func fn3() {
var t []T
var out [][]T
var m2 map[string][]T
for _, tt := range t {
out = append(out, m2[tt.F])
}
}
func fn4() {
var a, b, c []int
for _, v := range a {
b = append(c, v)
}
_ = b
}
func fn5() {
var t []T
var m2 map[string][]T
var out []T
for _, tt := range t {
out = append(m2[tt.F], tt)
}
_ = out
}
go-tools-2021.1.2/simple/testdata/src/nil-len/ 0000775 0000000 0000000 00000000000 14143223131 0020723 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/nil-len/nil-len.go 0000664 0000000 0000000 00000003274 14143223131 0022616 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var pa *[5]int
var s []int
var m map[int]int
var ch chan int
if s == nil || len(s) == 0 { // want `should omit nil check`
}
if m == nil || len(m) == 0 { // want `should omit nil check`
}
if ch == nil || len(ch) == 0 { // want `should omit nil check`
}
if s != nil && len(s) != 0 { // want `should omit nil check`
}
if m != nil && len(m) > 0 { // want `should omit nil check`
}
if s != nil && len(s) > 5 { // want `should omit nil check`
}
if s != nil && len(s) >= 5 { // want `should omit nil check`
}
const five = 5
if s != nil && len(s) == five { // want `should omit nil check`
}
if ch != nil && len(ch) == 5 { // want `should omit nil check`
}
if pa == nil || len(pa) == 0 { // nil check cannot be removed with pointer to an array
}
if s == nil || len(m) == 0 { // different variables
}
if s != nil && len(m) == 1 { // different variables
}
var ch2 chan int
if ch == ch2 || len(ch) == 0 { // not comparing with nil
}
if ch != ch2 && len(ch) != 0 { // not comparing with nil
}
const zero = 0
if s != nil && len(s) == zero { // nil check is not redundant here
}
if s != nil && len(s) == 0 { // nil check is not redundant here
}
if s != nil && len(s) >= 0 { // nil check is not redundant here (though len(s) >= 0 is)
}
one := 1
if s != nil && len(s) == one { // nil check is not redundant here
}
if s != nil && len(s) == len(m) { // nil check is not redundant here
}
if s != nil && len(s) != 1 { // nil check is not redundant here
}
if s != nil && len(s) < 5 { // nil check is not redundant here
}
if s != nil && len(s) <= 5 { // nil check is not redundant here
}
if s != nil && len(s) != len(ch) { // nil check is not redundant here
}
}
go-tools-2021.1.2/simple/testdata/src/range_go13/ 0000775 0000000 0000000 00000000000 14143223131 0021312 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/range_go13/range_go13.go 0000664 0000000 0000000 00000000551 14143223131 0023567 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var m map[string]int
// with :=
for x, _ := range m {
_ = x
}
// with =
var y string
_ = y
for y, _ = range m {
}
// all OK:
for x := range m {
_ = x
}
for x, y := range m {
_, _ = x, y
}
for _, y := range m {
_ = y
}
var x int
_ = x
for y = range m {
}
for y, x = range m {
}
for _, x = range m {
}
}
go-tools-2021.1.2/simple/testdata/src/range_go14/ 0000775 0000000 0000000 00000000000 14143223131 0021313 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/range_go14/range_go14.go 0000664 0000000 0000000 00000001176 14143223131 0023575 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var m map[string]int
// with :=
for x, _ := range m { // want `unnecessary assignment to the blank identifier`
_ = x
}
// with =
var y string
_ = y
for y, _ = range m { // want `unnecessary assignment to the blank identifier`
}
for _ = range m { // want `unnecessary assignment to the blank identifier`
}
for _, _ = range m { // want `unnecessary assignment to the blank identifier`
}
// all OK:
for x := range m {
_ = x
}
for x, y := range m {
_, _ = x, y
}
for _, y := range m {
_ = y
}
var x int
_ = x
for y = range m {
}
for y, x = range m {
}
for _, x = range m {
}
}
go-tools-2021.1.2/simple/testdata/src/range_go14/range_go14.go.golden 0000664 0000000 0000000 00000001155 14143223131 0025041 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var m map[string]int
// with :=
for x := range m { // want `unnecessary assignment to the blank identifier`
_ = x
}
// with =
var y string
_ = y
for y = range m { // want `unnecessary assignment to the blank identifier`
}
for range m { // want `unnecessary assignment to the blank identifier`
}
for range m { // want `unnecessary assignment to the blank identifier`
}
// all OK:
for x := range m {
_ = x
}
for x, y := range m {
_, _ = x, y
}
for _, y := range m {
_ = y
}
var x int
_ = x
for y = range m {
}
for y, x = range m {
}
for _, x = range m {
}
}
go-tools-2021.1.2/simple/testdata/src/receive-blank/ 0000775 0000000 0000000 00000000000 14143223131 0022074 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/receive-blank/receive-blank.go 0000664 0000000 0000000 00000000435 14143223131 0025134 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var ch chan int
<-ch
_ = <-ch // want `unnecessary assignment to the blank identifier`
select {
case <-ch:
case _ = <-ch: // want `unnecessary assignment to the blank identifier`
}
x := <-ch
y, _ := <-ch, <-ch
_, z := <-ch, <-ch
_, _, _ = x, y, z
}
go-tools-2021.1.2/simple/testdata/src/receive-blank/receive-blank.go.golden 0000664 0000000 0000000 00000000425 14143223131 0026402 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var ch chan int
<-ch
<-ch // want `unnecessary assignment to the blank identifier`
select {
case <-ch:
case <-ch: // want `unnecessary assignment to the blank identifier`
}
x := <-ch
y, _ := <-ch, <-ch
_, z := <-ch, <-ch
_, _, _ = x, y, z
}
go-tools-2021.1.2/simple/testdata/src/regexp-raw/ 0000775 0000000 0000000 00000000000 14143223131 0021446 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/regexp-raw/regexp-raw.go 0000664 0000000 0000000 00000000735 14143223131 0024063 0 ustar 00root root 0000000 0000000 package pkg
import "regexp"
func fn2() string { return "" }
func fn() {
x := "abc"
const y = "abc"
regexp.MustCompile(`\\.`)
regexp.MustCompile("\\.") // want `should use raw string.+\.MustCompile`
regexp.Compile("\\.") // want `should use raw string.+\.Compile`
regexp.Compile("\\.`")
regexp.MustCompile("(?m:^lease (.+?) {\n((?s).+?)\\n}\n)")
regexp.MustCompile("\\*/[ \t\n\r\f\v]*;")
regexp.MustCompile(fn2())
regexp.MustCompile(x)
regexp.MustCompile(y)
}
go-tools-2021.1.2/simple/testdata/src/single-case-select/ 0000775 0000000 0000000 00000000000 14143223131 0023034 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/single-case-select/single-case-select.go 0000664 0000000 0000000 00000000564 14143223131 0027037 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var ch chan int
select { // want `should use a simple channel send`
case <-ch:
}
outer:
for { // want `should use for range`
select {
case <-ch:
break outer
}
}
for { // want `should use for range`
select {
case x := <-ch:
_ = x
}
}
for {
select { // want `should use a simple channel send`
case ch <- 0:
}
}
}
go-tools-2021.1.2/simple/testdata/src/slicing/ 0000775 0000000 0000000 00000000000 14143223131 0021015 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/slicing/slicing.go 0000664 0000000 0000000 00000000217 14143223131 0022774 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var s [5]int
_ = s[:len(s)] // want `omit second index`
len := func(s [5]int) int { return -1 }
_ = s[:len(s)]
}
go-tools-2021.1.2/simple/testdata/src/slicing/slicing.go.golden 0000664 0000000 0000000 00000000211 14143223131 0024235 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var s [5]int
_ = s[:] // want `omit second index`
len := func(s [5]int) int { return -1 }
_ = s[:len(s)]
}
go-tools-2021.1.2/simple/testdata/src/time-since/ 0000775 0000000 0000000 00000000000 14143223131 0021422 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/time-since/time-since.go 0000664 0000000 0000000 00000000233 14143223131 0024004 0 ustar 00root root 0000000 0000000 package pkg
import "time"
func fn() {
t1 := time.Now()
_ = time.Now().Sub(t1) // want `time\.Since`
_ = time.Date(0, 0, 0, 0, 0, 0, 0, nil).Sub(t1)
}
go-tools-2021.1.2/simple/testdata/src/time-since/time-since.go.golden 0000664 0000000 0000000 00000000227 14143223131 0025256 0 ustar 00root root 0000000 0000000 package pkg
import "time"
func fn() {
t1 := time.Now()
_ = time.Since(t1) // want `time\.Since`
_ = time.Date(0, 0, 0, 0, 0, 0, 0, nil).Sub(t1)
}
go-tools-2021.1.2/simple/testdata/src/trim/ 0000775 0000000 0000000 00000000000 14143223131 0020340 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/simple/testdata/src/trim/trim.go 0000664 0000000 0000000 00000007750 14143223131 0021653 0 ustar 00root root 0000000 0000000 package pkg
import (
"bytes"
"strings"
)
func foo(s string) int { return 0 }
func gen() string {
return ""
}
func fn() {
const s1 = "a string value"
var s2 = "a string value"
const n = 14
var id1 = "a string value"
var id2 string
if strings.HasPrefix(id1, s1) { // want `should replace.*with.*strings\.TrimPrefix`
id1 = id1[len(s1):]
}
if strings.HasPrefix(id1, s1) { // want `should replace.*with.*strings\.TrimPrefix`
id1 = strings.TrimPrefix(id1, s1)
}
if strings.HasPrefix(id1, s1) {
id1 = strings.TrimPrefix(id1, s2)
}
if strings.Contains(id1, s1) { // want `should replace.*with.*strings\.Replace`
id1 = strings.Replace(id1, s1, "something", 123)
}
if strings.HasSuffix(id1, s2) { // want `should replace.*with.*strings\.TrimSuffix`
id1 = id1[:len(id1)-len(s2)]
}
var x, y []string
var i int
if strings.HasPrefix(x[i], s1) { // want `should replace.*with.*strings\.TrimPrefix`
x[i] = x[i][len(s1):]
}
if strings.HasPrefix(x[i], y[i]) { // want `should replace.*with.*strings\.TrimPrefix`
x[i] = x[i][len(y[i]):]
}
var t struct{ x string }
if strings.HasPrefix(t.x, s1) { // want `should replace.*with.*strings\.TrimPrefix`
t.x = t.x[len(s1):]
}
if strings.HasPrefix(id1, "test") { // want `should replace.*with.*strings\.TrimPrefix`
id1 = id1[len("test"):]
}
if strings.HasPrefix(id1, "test") { // want `should replace.*with.*strings\.TrimPrefix`
id1 = id1[4:]
}
if strings.HasPrefix(id1, s1) { // not allowed, 14 and s1 aren't obviously connected
id1 = id1[14:]
}
if strings.HasPrefix(id1, s1) { // not allowed, s1 and n aren't obviously connected
id1 = id1[n:]
}
var b1, b2 []byte
if bytes.HasPrefix(b1, b2) { // want `should replace.*with.*bytes\.TrimPrefix`
b1 = b1[len(b2):]
}
id3 := s2
if strings.HasPrefix(id1, id3) { // want `should replace.*with.*strings\.TrimPrefix`
id1 = id1[len(id3):]
}
if strings.HasSuffix(id1, s2) {
id1 = id1[:len(id1)+len(s2)] // wrong operator
}
if strings.HasSuffix(id1, s2) {
id1 = id1[:len(s2)-len(id1)] // wrong math
}
if strings.HasSuffix(id1, s2) {
id1 = id1[:len(id1)-len(id1)] // wrong string length
}
if strings.HasPrefix(id1, gen()) {
id1 = id1[len(gen()):] // dynamic id3
}
if strings.HasPrefix(id1, s1) {
id1 = id1[foo(s1):] // wrong function
}
if strings.HasPrefix(id1, s1) {
id1 = id1[len(id1):] // len() on wrong value
}
if strings.HasPrefix(id1, "test") {
id1 = id1[5:] // wrong length
}
if strings.HasPrefix(id1, s1) {
id1 = id1[len(s1)+1:] // wrong length due to math
}
if strings.HasPrefix(id1, s1) {
id2 = id1[len(s1):] // assigning to the wrong variable
}
if strings.HasPrefix(id1, s1) {
id1 = id1[len(s1):15] // has a max
}
if strings.HasPrefix(id1, s1) {
id1 = id2[len(s1):] // assigning the wrong value
}
if strings.HasPrefix(id1, s1) {
id1 = id1[len(s1):]
id1 += "" // doing more work in the if
}
if strings.HasPrefix(id1, s1) {
id1 = id1[len(s1):]
} else {
id1 = "game over" // else branch
}
if strings.HasPrefix(id1, s1) {
// the conditional is guarding additional code
id1 = id1[len(s1):]
println(id1)
}
if strings.Contains(id1, s1) {
id1 = id1[:]
}
}
func fn2() {
var s string
const id = ".json"
if strings.HasSuffix(s, ".json") { // want `should replace.*with.*strings\.TrimSuffix`
s = strings.TrimSuffix(s, ".json")
}
if strings.HasSuffix(s, ".json") { // want `should replace.*with.*strings\.TrimSuffix`
s = s[:len(s)-len(".json")]
}
if strings.HasSuffix(s, ".json") { // want `should replace.*with.*strings\.TrimSuffix`
s = s[:len(s)-5]
}
if strings.HasSuffix(s, id) {
s = s[:len(s)-5] // second argument of HasSuffix it not a string literal
}
if strings.HasSuffix(s, ".json") {
s = s[:len(s)-4] // wrong length
}
}
func fn3() {
const s1 = "a string value"
var id1 = "a string value"
len := func(string) int { return 0 } // don't accept non-builtin definition of len
if strings.HasPrefix(id1, s1) {
id1 = id1[len(s1):]
}
if strings.HasSuffix(id1, s1) {
id1 = id1[:len(id1)-len(s1)]
}
}
go-tools-2021.1.2/staticcheck/ 0000775 0000000 0000000 00000000000 14143223131 0015761 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/analysis.go 0000664 0000000 0000000 00000021272 14143223131 0020137 0 ustar 00root root 0000000 0000000 package staticcheck
import (
"honnef.co/go/tools/analysis/facts"
"honnef.co/go/tools/analysis/facts/nilness"
"honnef.co/go/tools/analysis/facts/typedness"
"honnef.co/go/tools/analysis/lint"
"honnef.co/go/tools/internal/passes/buildir"
"golang.org/x/tools/go/analysis"
"golang.org/x/tools/go/analysis/passes/inspect"
)
func makeCallCheckerAnalyzer(rules map[string]CallCheck, extraReqs ...*analysis.Analyzer) *analysis.Analyzer {
reqs := []*analysis.Analyzer{buildir.Analyzer, facts.TokenFile}
reqs = append(reqs, extraReqs...)
return &analysis.Analyzer{
Run: callChecker(rules),
Requires: reqs,
}
}
var Analyzers = lint.InitializeAnalyzers(Docs, map[string]*analysis.Analyzer{
"SA1000": makeCallCheckerAnalyzer(checkRegexpRules),
"SA1001": {
Run: CheckTemplate,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA1002": makeCallCheckerAnalyzer(checkTimeParseRules),
"SA1003": makeCallCheckerAnalyzer(checkEncodingBinaryRules),
"SA1004": {
Run: CheckTimeSleepConstant,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA1005": {
Run: CheckExec,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA1006": {
Run: CheckUnsafePrintf,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA1007": makeCallCheckerAnalyzer(checkURLsRules),
"SA1008": {
Run: CheckCanonicalHeaderKey,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA1010": makeCallCheckerAnalyzer(checkRegexpFindAllRules),
"SA1011": makeCallCheckerAnalyzer(checkUTF8CutsetRules),
"SA1012": {
Run: CheckNilContext,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA1013": {
Run: CheckSeeker,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA1014": makeCallCheckerAnalyzer(checkUnmarshalPointerRules),
"SA1015": {
Run: CheckLeakyTimeTick,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA1016": {
Run: CheckUntrappableSignal,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA1017": makeCallCheckerAnalyzer(checkUnbufferedSignalChanRules),
"SA1018": makeCallCheckerAnalyzer(checkStringsReplaceZeroRules),
"SA1019": {
Run: CheckDeprecated,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Deprecated, facts.Generated},
},
"SA1020": makeCallCheckerAnalyzer(checkListenAddressRules),
"SA1021": makeCallCheckerAnalyzer(checkBytesEqualIPRules),
"SA1023": {
Run: CheckWriterBufferModified,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA1024": makeCallCheckerAnalyzer(checkUniqueCutsetRules),
"SA1025": {
Run: CheckTimerResetReturnValue,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA1026": makeCallCheckerAnalyzer(checkUnsupportedMarshal),
"SA1027": makeCallCheckerAnalyzer(checkAtomicAlignment),
"SA1028": makeCallCheckerAnalyzer(checkSortSliceRules),
"SA1029": makeCallCheckerAnalyzer(checkWithValueKeyRules),
"SA1030": makeCallCheckerAnalyzer(checkStrconvRules),
"SA2000": {
Run: CheckWaitgroupAdd,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA2001": {
Run: CheckEmptyCriticalSection,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA2002": {
Run: CheckConcurrentTesting,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA2003": {
Run: CheckDeferLock,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA3000": {
Run: CheckTestMainExit,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA3001": {
Run: CheckBenchmarkN,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA4000": {
Run: CheckLhsRhsIdentical,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.TokenFile, facts.Generated},
},
"SA4001": {
Run: CheckIneffectiveCopy,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA4003": {
Run: CheckExtremeComparison,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA4004": {
Run: CheckIneffectiveLoop,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA4005": {
Run: CheckIneffectiveFieldAssignments,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA4006": {
Run: CheckUnreadVariableValues,
Requires: []*analysis.Analyzer{buildir.Analyzer, facts.Generated},
},
"SA4008": {
Run: CheckLoopCondition,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA4009": {
Run: CheckArgOverwritten,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA4010": {
Run: CheckIneffectiveAppend,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA4011": {
Run: CheckScopedBreak,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA4012": {
Run: CheckNaNComparison,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA4013": {
Run: CheckDoubleNegation,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA4014": {
Run: CheckRepeatedIfElse,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA4015": makeCallCheckerAnalyzer(checkMathIntRules),
"SA4016": {
Run: CheckSillyBitwiseOps,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.TokenFile},
},
"SA4017": {
Run: CheckPureFunctions,
Requires: []*analysis.Analyzer{buildir.Analyzer, facts.Purity},
},
"SA4018": {
Run: CheckSelfAssignment,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated, facts.TokenFile, facts.Purity},
},
"SA4019": {
Run: CheckDuplicateBuildConstraints,
Requires: []*analysis.Analyzer{facts.Generated},
},
"SA4020": {
Run: CheckUnreachableTypeCases,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA4021": {
Run: CheckSingleArgAppend,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated, facts.TokenFile},
},
"SA4022": {
Run: CheckAddressIsNil,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA4023": {
Run: CheckTypedNilInterface,
Requires: []*analysis.Analyzer{buildir.Analyzer, typedness.Analysis, nilness.Analysis},
},
"SA4024": {
Run: CheckBuiltinZeroComparison,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA4025": {
Run: CheckIntegerDivisionEqualsZero,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA4026": {
Run: CheckNegativeZeroFloat,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA4027": {
Run: CheckIneffectiveURLQueryModification,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA5000": {
Run: CheckNilMaps,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA5001": {
Run: CheckEarlyDefer,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA5002": {
Run: CheckInfiniteEmptyLoop,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA5003": {
Run: CheckDeferInInfiniteLoop,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA5004": {
Run: CheckLoopEmptyDefault,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA5005": {
Run: CheckCyclicFinalizer,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA5007": {
Run: CheckInfiniteRecursion,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA5008": {
Run: CheckStructTags,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA5009": makeCallCheckerAnalyzer(checkPrintfRules),
"SA5010": {
Run: CheckImpossibleTypeAssertion,
Requires: []*analysis.Analyzer{buildir.Analyzer, facts.TokenFile},
},
"SA5011": {
Run: CheckMaybeNil,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA5012": {
Run: CheckEvenSliceLength,
FactTypes: []analysis.Fact{new(evenElements)},
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA6000": makeCallCheckerAnalyzer(checkRegexpMatchLoopRules),
"SA6001": {
Run: CheckMapBytesKey,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA6002": makeCallCheckerAnalyzer(checkSyncPoolValueRules),
"SA6003": {
Run: CheckRangeStringRunes,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"SA6005": {
Run: CheckToLowerToUpperComparison,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA9001": {
Run: CheckDubiousDeferInChannelRangeLoop,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA9002": {
Run: CheckNonOctalFileMode,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"SA9003": {
Run: CheckEmptyBranch,
Requires: []*analysis.Analyzer{buildir.Analyzer, facts.TokenFile, facts.Generated},
},
"SA9004": {
Run: CheckMissingEnumTypesInDeclaration,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
// Filtering generated code because it may include empty structs generated from data models.
"SA9005": makeCallCheckerAnalyzer(checkNoopMarshal, facts.Generated),
"SA9006": {
Run: CheckStaticBitShift,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
})
go-tools-2021.1.2/staticcheck/buildtag.go 0000664 0000000 0000000 00000000643 14143223131 0020106 0 ustar 00root root 0000000 0000000 package staticcheck
import (
"go/ast"
"strings"
"honnef.co/go/tools/go/ast/astutil"
)
func buildTags(f *ast.File) [][]string {
var out [][]string
for _, line := range strings.Split(astutil.Preamble(f), "\n") {
if !strings.HasPrefix(line, "+build ") {
continue
}
line = strings.TrimSpace(strings.TrimPrefix(line, "+build "))
fields := strings.Fields(line)
out = append(out, fields)
}
return out
}
go-tools-2021.1.2/staticcheck/doc.go 0000664 0000000 0000000 00000104311 14143223131 0017055 0 ustar 00root root 0000000 0000000 package staticcheck
import "honnef.co/go/tools/analysis/lint"
var Docs = lint.Markdownify(map[string]*lint.Documentation{
"SA1000": {
Title: `Invalid regular expression`,
Since: "2017.1",
Severity: lint.SeverityError,
},
"SA1001": {
Title: `Invalid template`,
Since: "2017.1",
Severity: lint.SeverityError,
},
"SA1002": {
Title: "Invalid format in `time.Parse`",
Since: "2017.1",
Severity: lint.SeverityError,
},
"SA1003": {
Title: "Unsupported argument to functions in `encoding/binary`",
Text: `The \'encoding/binary\' package can only serialize types with known sizes.
This precludes the use of the \'int\' and \'uint\' types, as their sizes
differ on different architectures. Furthermore, it doesn't support
serializing maps, channels, strings, or functions.
Before Go 1.8, \'bool\' wasn't supported, either.`,
Since: "2017.1",
Severity: lint.SeverityError,
},
"SA1004": {
Title: "Suspiciously small untyped constant in `time.Sleep`",
Text: `The \'time\'.Sleep function takes a \'time.Duration\' as its only argument.
Durations are expressed in nanoseconds. Thus, calling \'time.Sleep(1)\'
will sleep for 1 nanosecond. This is a common source of bugs, as sleep
functions in other languages often accept seconds or milliseconds.
The \'time\' package provides constants such as \'time.Second\' to express
large durations. These can be combined with arithmetic to express
arbitrary durations, for example \'5 * time.Second\' for 5 seconds.
If you truly meant to sleep for a tiny amount of time, use
\'n * time.Nanosecond\' to signal to Staticcheck that you did mean to sleep
for some amount of nanoseconds.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA1005": {
Title: "Invalid first argument to `exec.Command`",
Text: `\'os/exec\' runs programs directly (using variants of the fork and exec
system calls on Unix systems). This shouldn't be confused with running
a command in a shell. The shell will allow for features such as input
redirection, pipes, and general scripting. The shell is also
responsible for splitting the user's input into a program name and its
arguments. For example, the equivalent to
ls / /tmp
would be
exec.Command("ls", "/", "/tmp")
If you want to run a command in a shell, consider using something like
the following β but be aware that not all systems, particularly
Windows, will have a \'/bin/sh\' program:
exec.Command("/bin/sh", "-c", "ls | grep Awesome")`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA1006": {
Title: `Printf with dynamic first argument and no further arguments`,
Text: `Using \'fmt.Printf\' with a dynamic first argument can lead to unexpected
output. The first argument is a format string, where certain character
combinations have special meaning. If, for example, a user were to
enter a string such as
Interest rate: 5%
and you printed it with
fmt.Printf(s)
it would lead to the following output:
Interest rate: 5%!(NOVERB).
Similarly, forming the first parameter via string concatenation with
user input should be avoided for the same reason. When printing user
input, either use a variant of fmt.Print, or use the \'%s\' Printf verb
and pass the string as an argument.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA1007": {
Title: "Invalid URL in `net/url.Parse`",
Since: "2017.1",
Severity: lint.SeverityError,
},
"SA1008": {
Title: "Non-canonical key in `http.Header` map",
Text: `Keys in \'http.Header\' maps are canonical, meaning they follow a specific
combination of uppercase and lowercase letters. Methods such as
\'http.Header.Add\' and \'http.Header.Del\' convert inputs into this canonical
form before manipulating the map.
When manipulating \'http.Header\' maps directly, as opposed to using the
provided methods, care should be taken to stick to canonical form in
order to avoid inconsistencies. The following piece of code
demonstrates one such inconsistency:
h := http.Header{}
h["etag"] = []string{"1234"}
h.Add("etag", "5678")
fmt.Println(h)
// Output:
// map[Etag:[5678] etag:[1234]]
The easiest way of obtaining the canonical form of a key is to use
\'http.CanonicalHeaderKey\'.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA1010": {
Title: "`(*regexp.Regexp).FindAll` called with `n == 0`, which will always return zero results",
Text: `If n >= 0, the function returns at most n matches/submatches. To
return all results, specify a negative number.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA1011": {
Title: "Various methods in the `strings` package expect valid UTF-8, but invalid input is provided",
Since: "2017.1",
Severity: lint.SeverityError,
},
"SA1012": {
Title: "A nil `context.Context` is being passed to a function, consider using `context.TODO` instead",
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA1013": {
Title: "`io.Seeker.Seek` is being called with the whence constant as the first argument, but it should be the second",
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA1014": {
Title: "Non-pointer value passed to `Unmarshal` or `Decode`",
Since: "2017.1",
Severity: lint.SeverityError,
},
"SA1015": {
Title: "Using `time.Tick` in a way that will leak. Consider using `time.NewTicker`, and only use `time.Tick` in tests, commands and endless functions",
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA1016": {
Title: `Trapping a signal that cannot be trapped`,
Text: `Not all signals can be intercepted by a process. Specifically, on
UNIX-like systems, the \'syscall.SIGKILL\' and \'syscall.SIGSTOP\' signals are
never passed to the process, but instead handled directly by the
kernel. It is therefore pointless to try and handle these signals.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA1017": {
Title: "Channels used with `os/signal.Notify` should be buffered",
Text: `The \'os/signal\' package uses non-blocking channel sends when delivering
signals. If the receiving end of the channel isn't ready and the
channel is either unbuffered or full, the signal will be dropped. To
avoid missing signals, the channel should be buffered and of the
appropriate size. For a channel used for notification of just one
signal value, a buffer of size 1 is sufficient.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA1018": {
Title: "`strings.Replace` called with `n == 0`, which does nothing",
Text: `With n == 0, zero instances will be replaced. To replace all
instances, use a negative number, or use strings.ReplaceAll.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA1019": {
Title: `Using a deprecated function, variable, constant or field`,
Since: "2017.1",
Severity: lint.SeverityDeprecated,
},
"SA1020": {
Title: "Using an invalid host:port pair with a `net.Listen`-related function",
Since: "2017.1",
Severity: lint.SeverityError,
},
"SA1021": {
Title: "Using `bytes.Equal` to compare two `net.IP`",
Text: `A \'net.IP\' stores an IPv4 or IPv6 address as a slice of bytes. The
length of the slice for an IPv4 address, however, can be either 4 or
16 bytes long, using different ways of representing IPv4 addresses. In
order to correctly compare two \'net.IP\'s, the \'net.IP.Equal\' method should
be used, as it takes both representations into account.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA1023": {
Title: "Modifying the buffer in an `io.Writer` implementation",
Text: `\'Write\' must not modify the slice data, even temporarily.`,
Since: "2017.1",
Severity: lint.SeverityError,
},
"SA1024": {
Title: `A string cutset contains duplicate characters`,
Text: `The \'strings.TrimLeft\' and \'strings.TrimRight\' functions take cutsets, not
prefixes. A cutset is treated as a set of characters to remove from a
string. For example,
strings.TrimLeft("42133word", "1234"))
will result in the string \'"word"\' β any characters that are 1, 2, 3 or
4 are cut from the left of the string.
In order to remove one string from another, use \'strings.TrimPrefix\' instead.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA1025": {
Title: "It is not possible to use `(*time.Timer).Reset`'s return value correctly",
Since: "2019.1",
Severity: lint.SeverityWarning,
},
"SA1026": {
Title: `Cannot marshal channels or functions`,
Since: "2019.2",
Severity: lint.SeverityError,
},
"SA1027": {
Title: `Atomic access to 64-bit variable must be 64-bit aligned`,
Text: `On ARM, x86-32, and 32-bit MIPS, it is the caller's responsibility to
arrange for 64-bit alignment of 64-bit words accessed atomically. The
first word in a variable or in an allocated struct, array, or slice
can be relied upon to be 64-bit aligned.
You can use the structlayout tool to inspect the alignment of fields
in a struct.`,
Since: "2019.2",
Severity: lint.SeverityWarning,
},
"SA1028": {
Title: "`sort.Slice` can only be used on slices",
Text: `The first argument of sort.Slice must be a slice.`,
Since: "2020.1",
Severity: lint.SeverityError,
},
"SA1029": {
Title: "Inappropriate key in call to `context.WithValue`",
Text: `The provided key must be comparable and should not be
of type string or any other built-in type to avoid collisions between
packages using context. Users of \'WithValue\' should define their own
types for keys.
To avoid allocating when assigning to an \'interface{}\',
context keys often have concrete type struct{}. Alternatively,
exported context key variables' static type should be a pointer or
interface.`,
Since: "2020.1",
Severity: lint.SeverityWarning,
},
"SA1030": {
Title: "Invalid argument in call to a `strconv` function",
Text: `This check validates the format, number base and bit size arguments of
the various parsing and formatting functions in \'strconv\'.`,
Since: "2021.1",
Severity: lint.SeverityError,
},
"SA2000": {
Title: "`sync.WaitGroup.Add` called inside the goroutine, leading to a race condition",
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA2001": {
Title: `Empty critical section, did you mean to defer the unlock?`,
Text: `Empty critical sections of the kind
mu.Lock()
mu.Unlock()
are very often a typo, and the following was intended instead:
mu.Lock()
defer mu.Unlock()
Do note that sometimes empty critical sections can be useful, as a
form of signaling to wait on another goroutine. Many times, there are
simpler ways of achieving the same effect. When that isn't the case,
the code should be amply commented to avoid confusion. Combining such
comments with a \'//lint:ignore\' directive can be used to suppress this
rare false positive.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA2002": {
Title: "Called `testing.T.FailNow` or `SkipNow` in a goroutine, which isn't allowed",
Since: "2017.1",
Severity: lint.SeverityError,
},
"SA2003": {
Title: "Deferred `Lock` right after locking, likely meant to defer `Unlock` instead",
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA3000": {
Title: "`TestMain` doesn't call `os.Exit`, hiding test failures",
Text: `Test executables (and in turn \'go test\') exit with a non-zero status
code if any tests failed. When specifying your own TestMain function,
it is your responsibility to arrange for this, by calling \'os.Exit\' with
the correct code. The correct code is returned by \'(*testing.M).Run\', so
the usual way of implementing TestMain is to end it with
\'os.Exit(m.Run())\'.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA3001": {
Title: "Assigning to `b.N` in benchmarks distorts the results",
Text: `The testing package dynamically sets \'b.N\' to improve the reliability of
benchmarks and uses it in computations to determine the duration of a
single operation. Benchmark code must not alter \'b.N\' as this would
falsify results.`,
Since: "2017.1",
Severity: lint.SeverityError,
},
"SA4000": {
Title: `Boolean expression has identical expressions on both sides`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4001": {
Title: "`&*x` gets simplified to `x`, it does not copy `x`",
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4002": {
Title: `Comparing strings with known different sizes has predictable results`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4003": {
Title: `Comparing unsigned values against negative values is pointless`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4004": {
Title: `The loop exits unconditionally after one iteration`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4005": {
Title: `Field assignment that will never be observed. Did you mean to use a pointer receiver?`,
Since: "2021.1",
Severity: lint.SeverityWarning,
},
"SA4006": {
Title: `A value assigned to a variable is never read before being overwritten. Forgotten error check or dead code?`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4008": {
Title: `The variable in the loop condition never changes, are you incrementing the wrong variable?`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4009": {
Title: `A function argument is overwritten before its first use`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4010": {
Title: "The result of `append` will never be observed anywhere",
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4011": {
Title: `Break statement with no effect. Did you mean to break out of an outer loop?`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4012": {
Title: `Comparing a value against NaN even though no value is equal to NaN`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4013": {
Title: "Negating a boolean twice (`!!b`) is the same as writing `b`. This is either redundant, or a typo.",
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4014": {
Title: `An if/else if chain has repeated conditions and no side-effects; if the condition didn't match the first time, it won't match the second time, either`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4015": {
Title: "Calling functions like `math.Ceil` on floats converted from integers doesn't do anything useful",
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4016": {
Title: "Certain bitwise operations, such as `x ^ 0`, do not do anything useful",
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4017": {
Title: `A pure function's return value is discarded, making the call pointless`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4018": {
Title: `Self-assignment of variables`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4019": {
Title: `Multiple, identical build constraints in the same file`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA4020": {
Title: `Unreachable case clause in a type switch`,
Text: `In a type switch like the following
type T struct{}
func (T) Read(b []byte) (int, error) { return 0, nil }
var v interface{} = T{}
switch v.(type) {
case io.Reader:
// ...
case T:
// unreachable
}
the second case clause can never be reached because \'T\' implements
\'io.Reader\' and case clauses are evaluated in source order.
Another example:
type T struct{}
func (T) Read(b []byte) (int, error) { return 0, nil }
func (T) Close() error { return nil }
var v interface{} = T{}
switch v.(type) {
case io.Reader:
// ...
case io.ReadCloser:
// unreachable
}
Even though \'T\' has a \'Close\' method and thus implements \'io.ReadCloser\',
\'io.Reader\' will always match first. The method set of \'io.Reader\' is a
subset of \'io.ReadCloser\'. Thus it is impossible to match the second
case without matching the first case.
Structurally equivalent interfaces
A special case of the previous example are structurally identical
interfaces. Given these declarations
type T error
type V error
func doSomething() error {
err, ok := doAnotherThing()
if ok {
return T(err)
}
return U(err)
}
the following type switch will have an unreachable case clause:
switch doSomething().(type) {
case T:
// ...
case V:
// unreachable
}
\'T\' will always match before V because they are structurally equivalent
and therefore \'doSomething()\''s return value implements both.`,
Since: "2019.2",
Severity: lint.SeverityWarning,
},
"SA4021": {
Title: "`x = append(y)` is equivalent to `x = y`",
Since: "2019.2",
Severity: lint.SeverityWarning,
},
"SA4022": {
Title: `Comparing the address of a variable against nil`,
Text: `Code such as \'if &x == nil\' is meaningless, because taking the address of a variable always yields a non-nil pointer.`,
Since: "2020.1",
Severity: lint.SeverityWarning,
},
"SA4023": {
Title: `Impossible comparison of interface value with untyped nil`,
Text: `Under the covers, interfaces are implemented as two elements, a
type T and a value V. V is a concrete value such as an int,
struct or pointer, never an interface itself, and has type T. For
instance, if we store the int value 3 in an interface, the
resulting interface value has, schematically, (T=int, V=3). The
value V is also known as the interface's dynamic value, since a
given interface variable might hold different values V (and
corresponding types T) during the execution of the program.
An interface value is nil only if the V and T are both
unset, (T=nil, V is not set), In particular, a nil interface will
always hold a nil type. If we store a nil pointer of type *int
inside an interface value, the inner type will be *int regardless
of the value of the pointer: (T=*int, V=nil). Such an interface
value will therefore be non-nil even when the pointer value V
inside is nil.
This situation can be confusing, and arises when a nil value is
stored inside an interface value such as an error return:
func returnsError() error {
var p *MyError = nil
if bad() {
p = ErrBad
}
return p // Will always return a non-nil error.
}
If all goes well, the function returns a nil p, so the return
value is an error interface value holding (T=*MyError, V=nil).
This means that if the caller compares the returned error to nil,
it will always look as if there was an error even if nothing bad
happened. To return a proper nil error to the caller, the
function must return an explicit nil:
func returnsError() error {
if bad() {
return ErrBad
}
return nil
}
It's a good idea for functions that return errors always to use
the error type in their signature (as we did above) rather than a
concrete type such as \'*MyError\', to help guarantee the error is
created correctly. As an example, \'os.Open\' returns an error even
though, if not nil, it's always of concrete type *os.PathError.
Similar situations to those described here can arise whenever
interfaces are used. Just keep in mind that if any concrete value
has been stored in the interface, the interface will not be nil.
For more information, see The Laws of
Reflection (https://golang.org/doc/articles/laws_of_reflection.html).
This text has been copied from
https://golang.org/doc/faq#nil_error, licensed under the Creative
Commons Attribution 3.0 License.`,
Since: "2020.2",
Severity: lint.SeverityWarning,
},
"SA4024": {
Title: `Checking for impossible return value from a builtin function`,
Text: `Return values of the \'len\' and \'cap\' builtins cannot be negative.
See https://golang.org/pkg/builtin/#len and https://golang.org/pkg/builtin/#cap.
Example:
if len(slice) < 0 {
fmt.Println("unreachable code")
}`,
Since: "2021.1",
Severity: lint.SeverityWarning,
},
"SA4025": {
Title: "Integer division of literals that results in zero",
Text: `When dividing two integer constants, the result will
also be an integer. Thus, a division such as '2 / 3' results in '0'.
This is true for all of the following examples:
_ = 2 / 3
const _ = 2 / 3
const _ float64 = 2 / 3
_ = float64(2 / 3)
Staticcheck will flag such divisions if both sides of the division are
integer literals, as it is highly unlikely that the division was
intended to truncate to zero. Staticcheck will not flag integer
division involving named constants, to avoid noisy positives.
`,
Since: "2021.1",
Severity: lint.SeverityWarning,
},
"SA4026": {
Title: "Go constants cannot express negative zero",
Text: `In IEEE 754 floating point math, zero has a sign and can be positive
or negative. This can be useful in certain numerical code.
Go constants, however, cannot express negative zero. This means that
the literals \'-0.0\' and \'0.0\' have the same ideal value (zero) and
will both represent positive zero at runtime.
To explicitly and reliably create a negative zero, you can use the
\'math.Copysign\' function: \'math.Copysign(0, -1)\'.`,
Since: "2021.1",
Severity: lint.SeverityWarning,
},
"SA4027": {
Title: "(*net/url.URL).Query returns a copy, modifying it doesn't change the URL",
Text: `\'(*net/url.URL).Query\' parses the current value of \'net/url.URL.RawQuery\'
and returns it as a map of type \'net/url.Values\'. Subsequent changes to
this map will not affect the URL unless the map gets encoded and
assigned to the URL's \'RawQuery\'.
As a consequence, the following code pattern is an expensive no-op:
\'u.Query().Add(key, value)\'.`,
Since: "2021.1",
Severity: lint.SeverityWarning,
},
"SA5000": {
Title: `Assignment to nil map`,
Since: "2017.1",
Severity: lint.SeverityError,
},
"SA5001": {
Title: "Deferring `Close` before checking for a possible error",
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA5002": {
Title: "The empty for loop (`for {}`) spins and can block the scheduler",
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA5003": {
Title: `Defers in infinite loops will never execute`,
Text: `Defers are scoped to the surrounding function, not the surrounding
block. In a function that never returns, i.e. one containing an
infinite loop, defers will never execute.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA5004": {
Title: "`for { select { ...` with an empty default branch spins",
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA5005": {
Title: `The finalizer references the finalized object, preventing garbage collection`,
Text: `A finalizer is a function associated with an object that runs when the
garbage collector is ready to collect said object, that is when the
object is no longer referenced by anything.
If the finalizer references the object, however, it will always remain
as the final reference to that object, preventing the garbage
collector from collecting the object. The finalizer will never run,
and the object will never be collected, leading to a memory leak. That
is why the finalizer should instead use its first argument to operate
on the object. That way, the number of references can temporarily go
to zero before the object is being passed to the finalizer.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA5006": {
Title: `Slice index out of bounds`,
Since: "2017.1",
Severity: lint.SeverityError,
},
"SA5007": {
Title: `Infinite recursive call`,
Text: `A function that calls itself recursively needs to have an exit
condition. Otherwise it will recurse forever, until the system runs
out of memory.
This issue can be caused by simple bugs such as forgetting to add an
exit condition. It can also happen "on purpose". Some languages have
tail call optimization which makes certain infinite recursive calls
safe to use. Go, however, does not implement TCO, and as such a loop
should be used instead.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA5008": {
Title: `Invalid struct tag`,
Since: "2019.2",
Severity: lint.SeverityWarning,
},
"SA5009": {
Title: `Invalid Printf call`,
Since: "2019.2",
Severity: lint.SeverityError,
},
"SA5010": {
Title: `Impossible type assertion`,
Text: `Some type assertions can be statically proven to be
impossible. This is the case when the method sets of both
arguments of the type assertion conflict with each other, for
example by containing the same method with different
signatures.
The Go compiler already applies this check when asserting from an
interface value to a concrete type. If the concrete type misses
methods from the interface, or if function signatures don't match,
then the type assertion can never succeed.
This check applies the same logic when asserting from one interface to
another. If both interface types contain the same method but with
different signatures, then the type assertion can never succeed,
either.`,
Since: "2020.1",
Severity: lint.SeverityWarning,
},
"SA5011": {
Title: `Possible nil pointer dereference`,
Text: `A pointer is being dereferenced unconditionally, while
also being checked against nil in another place. This suggests that
the pointer may be nil and dereferencing it may panic. This is
commonly a result of improperly ordered code or missing return
statements. Consider the following examples:
func fn(x *int) {
fmt.Println(*x)
// This nil check is equally important for the previous dereference
if x != nil {
foo(*x)
}
}
func TestFoo(t *testing.T) {
x := compute()
if x == nil {
t.Errorf("nil pointer received")
}
// t.Errorf does not abort the test, so if x is nil, the next line will panic.
foo(*x)
}
Staticcheck tries to deduce which functions abort control flow.
For example, it is aware that a function will not continue
execution after a call to \'panic\' or \'log.Fatal\'. However, sometimes
this detection fails, in particular in the presence of
conditionals. Consider the following example:
func Log(msg string, level int) {
fmt.Println(msg)
if level == levelFatal {
os.Exit(1)
}
}
func Fatal(msg string) {
Log(msg, levelFatal)
}
func fn(x *int) {
if x == nil {
Fatal("unexpected nil pointer")
}
fmt.Println(*x)
}
Staticcheck will flag the dereference of x, even though it is perfectly
safe. Staticcheck is not able to deduce that a call to
Fatal will exit the program. For the time being, the easiest
workaround is to modify the definition of Fatal like so:
func Fatal(msg string) {
Log(msg, levelFatal)
panic("unreachable")
}
We also hard-code functions from common logging packages such as
logrus. Please file an issue if we're missing support for a
popular package.`,
Since: "2020.1",
Severity: lint.SeverityWarning,
},
"SA5012": {
Title: "Passing odd-sized slice to function expecting even size",
Text: `Some functions that take slices as parameters expect the slices to have an even number of elements.
Often, these functions treat elements in a slice as pairs.
For example, \'strings.NewReplacer\' takes pairs of old and new strings,
and calling it with an odd number of elements would be an error.`,
Since: "2020.2",
Severity: lint.SeverityError,
},
"SA6000": {
Title: "Using `regexp.Match` or related in a loop, should use `regexp.Compile`",
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA6001": {
Title: `Missing an optimization opportunity when indexing maps by byte slices`,
Text: `Map keys must be comparable, which precludes the use of byte slices.
This usually leads to using string keys and converting byte slices to
strings.
Normally, a conversion of a byte slice to a string needs to copy the data and
causes allocations. The compiler, however, recognizes \'m[string(b)]\' and
uses the data of \'b\' directly, without copying it, because it knows that
the data can't change during the map lookup. This leads to the
counter-intuitive situation that
k := string(b)
println(m[k])
println(m[k])
will be less efficient than
println(m[string(b)])
println(m[string(b)])
because the first version needs to copy and allocate, while the second
one does not.
For some history on this optimization, check out commit
f5f5a8b6209f84961687d993b93ea0d397f5d5bf in the Go repository.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA6002": {
Title: "Storing non-pointer values in `sync.Pool` allocates memory",
Text: `A \'sync.Pool\' is used to avoid unnecessary allocations and reduce the
amount of work the garbage collector has to do.
When passing a value that is not a pointer to a function that accepts
an interface, the value needs to be placed on the heap, which means an
additional allocation. Slices are a common thing to put in sync.Pools,
and they're structs with 3 fields (length, capacity, and a pointer to
an array). In order to avoid the extra allocation, one should store a
pointer to the slice instead.
See the comments on https://go-review.googlesource.com/c/go/+/24371
that discuss this problem.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA6003": {
Title: `Converting a string to a slice of runes before ranging over it`,
Text: `You may want to loop over the runes in a string. Instead of converting
the string to a slice of runes and looping over that, you can loop
over the string itself. That is,
for _, r := range s {}
and
for _, r := range []rune(s) {}
will yield the same values. The first version, however, will be faster
and avoid unnecessary memory allocations.
Do note that if you are interested in the indices, ranging over a
string and over a slice of runes will yield different indices. The
first one yields byte offsets, while the second one yields indices in
the slice of runes.`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA6005": {
Title: "Inefficient string comparison with `strings.ToLower` or `strings.ToUpper`",
Text: `Converting two strings to the same case and comparing them like so
if strings.ToLower(s1) == strings.ToLower(s2) {
...
}
is significantly more expensive than comparing them with
\'strings.EqualFold(s1, s2)\'. This is due to memory usage as well as
computational complexity.
\'strings.ToLower\' will have to allocate memory for the new strings, as
well as convert both strings fully, even if they differ on the very
first byte. strings.EqualFold, on the other hand, compares the strings
one character at a time. It doesn't need to create two intermediate
strings and can return as soon as the first non-matching character has
been found.
For a more in-depth explanation of this issue, see
https://blog.digitalocean.com/how-to-efficiently-compare-strings-in-go/`,
Since: "2019.2",
Severity: lint.SeverityWarning,
},
"SA9001": {
Title: `Defers in range loops may not run when you expect them to`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA9002": {
Title: "Using a non-octal `os.FileMode` that looks like it was meant to be in octal.",
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA9003": {
Title: `Empty body in an if or else branch`,
Since: "2017.1",
Severity: lint.SeverityWarning,
},
"SA9004": {
Title: `Only the first constant has an explicit type`,
Text: `In a constant declaration such as the following:
const (
First byte = 1
Second = 2
)
the constant Second does not have the same type as the constant First.
This construct shouldn't be confused with
const (
First byte = iota
Second
)
where \'First\' and \'Second\' do indeed have the same type. The type is only
passed on when no explicit value is assigned to the constant.
When declaring enumerations with explicit values it is therefore
important not to write
const (
EnumFirst EnumType = 1
EnumSecond = 2
EnumThird = 3
)
This discrepancy in types can cause various confusing behaviors and
bugs.
Wrong type in variable declarations
The most obvious issue with such incorrect enumerations expresses
itself as a compile error:
package pkg
const (
EnumFirst uint8 = 1
EnumSecond = 2
)
func fn(useFirst bool) {
x := EnumSecond
if useFirst {
x = EnumFirst
}
}
fails to compile with
./const.go:11:5: cannot use EnumFirst (type uint8) as type int in assignment
Losing method sets
A more subtle issue occurs with types that have methods and optional
interfaces. Consider the following:
package main
import "fmt"
type Enum int
func (e Enum) String() string {
return "an enum"
}
const (
EnumFirst Enum = 1
EnumSecond = 2
)
func main() {
fmt.Println(EnumFirst)
fmt.Println(EnumSecond)
}
This code will output
an enum
2
as \'EnumSecond\' has no explicit type, and thus defaults to \'int\'.`,
Since: "2019.1",
Severity: lint.SeverityWarning,
},
"SA9005": {
Title: `Trying to marshal a struct with no public fields nor custom marshaling`,
Text: `The \'encoding/json\' and \'encoding/xml\' packages only operate on exported
fields in structs, not unexported ones. It is usually an error to try
to (un)marshal structs that only consist of unexported fields.
This check will not flag calls involving types that define custom
marshaling behavior, e.g. via \'MarshalJSON\' methods. It will also not
flag empty structs.`,
Since: "2019.2",
Severity: lint.SeverityWarning,
},
"SA9006": {
Title: `Dubious bit shifting of a fixed size integer value`,
Text: `Bit shifting a value past its size will always clear the value.
For instance:
v := int8(42)
v >>= 8
will always result in 0.
This check flags bit shifting operations on fixed size integer values only.
That is, int, uint and uintptr are never flagged to avoid potential false
positives in somewhat exotic but valid bit twiddling tricks:
// Clear any value above 32 bits if integers are more than 32 bits.
func f(i int) int {
v := i >> 32
v = v << 32
return i-v
}`,
Since: "2020.2",
Severity: lint.SeverityWarning,
},
})
go-tools-2021.1.2/staticcheck/fakejson/ 0000775 0000000 0000000 00000000000 14143223131 0017561 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/fakejson/encode.go 0000664 0000000 0000000 00000024026 14143223131 0021351 0 ustar 00root root 0000000 0000000 // Copyright 2010 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 contains a modified copy of the encoding/json encoder.
// All dynamic behavior has been removed, and reflecttion has been replaced with go/types.
// This allows us to statically find unmarshable types
// with the same rules for tags, shadowing and addressability as encoding/json.
// This is used for SA1026.
package fakejson
import (
"go/token"
"go/types"
"sort"
"strings"
"unicode"
"honnef.co/go/tools/staticcheck/fakereflect"
)
// parseTag splits a struct field's json tag into its name and
// comma-separated options.
func parseTag(tag string) string {
if idx := strings.Index(tag, ","); idx != -1 {
return tag[:idx]
}
return tag
}
func Marshal(v types.Type) *UnsupportedTypeError {
enc := encoder{
seen: map[fakereflect.TypeAndCanAddr]struct{}{},
}
return enc.newTypeEncoder(fakereflect.TypeAndCanAddr{Type: v}, "x")
}
// An UnsupportedTypeError is returned by Marshal when attempting
// to encode an unsupported value type.
type UnsupportedTypeError struct {
Type types.Type
Path string
}
var marshalerType = types.NewInterfaceType([]*types.Func{
types.NewFunc(token.NoPos, nil, "MarshalJSON", types.NewSignature(nil,
types.NewTuple(),
types.NewTuple(
types.NewVar(token.NoPos, nil, "", types.NewSlice(types.Typ[types.Byte])),
types.NewVar(0, nil, "", types.Universe.Lookup("error").Type())),
false,
)),
}, nil).Complete()
var textMarshalerType = types.NewInterfaceType([]*types.Func{
types.NewFunc(token.NoPos, nil, "MarshalText", types.NewSignature(nil,
types.NewTuple(),
types.NewTuple(
types.NewVar(token.NoPos, nil, "", types.NewSlice(types.Typ[types.Byte])),
types.NewVar(0, nil, "", types.Universe.Lookup("error").Type())),
false,
)),
}, nil).Complete()
type encoder struct {
seen map[fakereflect.TypeAndCanAddr]struct{}
}
func (enc *encoder) newTypeEncoder(t fakereflect.TypeAndCanAddr, stack string) *UnsupportedTypeError {
if _, ok := enc.seen[t]; ok {
return nil
}
enc.seen[t] = struct{}{}
if t.Implements(marshalerType) {
return nil
}
if !t.IsPtr() && t.CanAddr() && fakereflect.PtrTo(t).Implements(marshalerType) {
return nil
}
if t.Implements(textMarshalerType) {
return nil
}
if !t.IsPtr() && t.CanAddr() && fakereflect.PtrTo(t).Implements(textMarshalerType) {
return nil
}
switch t.Type.Underlying().(type) {
case *types.Basic, *types.Interface:
return nil
case *types.Struct:
return enc.typeFields(t, stack)
case *types.Map:
return enc.newMapEncoder(t, stack)
case *types.Slice:
return enc.newSliceEncoder(t, stack)
case *types.Array:
return enc.newArrayEncoder(t, stack)
case *types.Pointer:
// we don't have to express the pointer dereference in the path; x.f is syntactic sugar for (*x).f
return enc.newTypeEncoder(t.Elem(), stack)
default:
return &UnsupportedTypeError{t.Type, stack}
}
}
func (enc *encoder) newMapEncoder(t fakereflect.TypeAndCanAddr, stack string) *UnsupportedTypeError {
switch t.Key().Type.Underlying().(type) {
case *types.Basic:
default:
if !t.Key().Implements(textMarshalerType) {
return &UnsupportedTypeError{
Type: t.Type,
Path: stack,
}
}
}
return enc.newTypeEncoder(t.Elem(), stack+"[k]")
}
func (enc *encoder) newSliceEncoder(t fakereflect.TypeAndCanAddr, stack string) *UnsupportedTypeError {
// Byte slices get special treatment; arrays don't.
basic, ok := t.Elem().Type.Underlying().(*types.Basic)
if ok && basic.Kind() == types.Uint8 {
p := fakereflect.PtrTo(t.Elem())
if !p.Implements(marshalerType) && !p.Implements(textMarshalerType) {
return nil
}
}
return enc.newArrayEncoder(t, stack)
}
func (enc *encoder) newArrayEncoder(t fakereflect.TypeAndCanAddr, stack string) *UnsupportedTypeError {
return enc.newTypeEncoder(t.Elem(), stack+"[0]")
}
func isValidTag(s string) bool {
if s == "" {
return false
}
for _, c := range s {
switch {
case strings.ContainsRune("!#$%&()*+-./:;<=>?@[]^_{|}~ ", c):
// Backslash and quote chars are reserved, but
// otherwise any punctuation chars are allowed
// in a tag name.
case !unicode.IsLetter(c) && !unicode.IsDigit(c):
return false
}
}
return true
}
func typeByIndex(t fakereflect.TypeAndCanAddr, index []int) fakereflect.TypeAndCanAddr {
for _, i := range index {
if t.IsPtr() {
t = t.Elem()
}
t = t.Field(i).Type
}
return t
}
func pathByIndex(t fakereflect.TypeAndCanAddr, index []int) string {
path := ""
for _, i := range index {
if t.IsPtr() {
t = t.Elem()
}
path += "." + t.Field(i).Name
t = t.Field(i).Type
}
return path
}
// A field represents a single field found in a struct.
type field struct {
name string
tag bool
index []int
typ fakereflect.TypeAndCanAddr
}
// byIndex sorts field by index sequence.
type byIndex []field
func (x byIndex) Len() int { return len(x) }
func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
func (x byIndex) Less(i, j int) bool {
for k, xik := range x[i].index {
if k >= len(x[j].index) {
return false
}
if xik != x[j].index[k] {
return xik < x[j].index[k]
}
}
return len(x[i].index) < len(x[j].index)
}
// typeFields returns a list of fields that JSON should recognize for the given type.
// The algorithm is breadth-first search over the set of structs to include - the top struct
// and then any reachable anonymous structs.
func (enc *encoder) typeFields(t fakereflect.TypeAndCanAddr, stack string) *UnsupportedTypeError {
// Anonymous fields to explore at the current level and the next.
current := []field{}
next := []field{{typ: t}}
// Count of queued names for current level and the next.
var count, nextCount map[fakereflect.TypeAndCanAddr]int
// Types already visited at an earlier level.
visited := map[fakereflect.TypeAndCanAddr]bool{}
// Fields found.
var fields []field
for len(next) > 0 {
current, next = next, current[:0]
count, nextCount = nextCount, map[fakereflect.TypeAndCanAddr]int{}
for _, f := range current {
if visited[f.typ] {
continue
}
visited[f.typ] = true
// Scan f.typ for fields to include.
for i := 0; i < f.typ.NumField(); i++ {
sf := f.typ.Field(i)
if sf.Anonymous {
t := sf.Type
if t.IsPtr() {
t = t.Elem()
}
if !sf.IsExported() && !t.IsStruct() {
// Ignore embedded fields of unexported non-struct types.
continue
}
// Do not ignore embedded fields of unexported struct types
// since they may have exported fields.
} else if !sf.IsExported() {
// Ignore unexported non-embedded fields.
continue
}
tag := sf.Tag.Get("json")
if tag == "-" {
continue
}
name := parseTag(tag)
if !isValidTag(name) {
name = ""
}
index := make([]int, len(f.index)+1)
copy(index, f.index)
index[len(f.index)] = i
ft := sf.Type
if ft.Name() == "" && ft.IsPtr() {
// Follow pointer.
ft = ft.Elem()
}
// Record found field and index sequence.
if name != "" || !sf.Anonymous || !ft.IsStruct() {
tagged := name != ""
if name == "" {
name = sf.Name
}
field := field{
name: name,
tag: tagged,
index: index,
typ: ft,
}
fields = append(fields, field)
if count[f.typ] > 1 {
// If there were multiple instances, add a second,
// so that the annihilation code will see a duplicate.
// It only cares about the distinction between 1 or 2,
// so don't bother generating any more copies.
fields = append(fields, fields[len(fields)-1])
}
continue
}
// Record new anonymous struct to explore in next round.
nextCount[ft]++
if nextCount[ft] == 1 {
next = append(next, field{name: ft.Name(), index: index, typ: ft})
}
}
}
}
sort.Slice(fields, func(i, j int) bool {
x := fields
// sort field by name, breaking ties with depth, then
// breaking ties with "name came from json tag", then
// breaking ties with index sequence.
if x[i].name != x[j].name {
return x[i].name < x[j].name
}
if len(x[i].index) != len(x[j].index) {
return len(x[i].index) < len(x[j].index)
}
if x[i].tag != x[j].tag {
return x[i].tag
}
return byIndex(x).Less(i, j)
})
// Delete all fields that are hidden by the Go rules for embedded fields,
// except that fields with JSON tags are promoted.
// The fields are sorted in primary order of name, secondary order
// of field index length. Loop over names; for each name, delete
// hidden fields by choosing the one dominant field that survives.
out := fields[:0]
for advance, i := 0, 0; i < len(fields); i += advance {
// One iteration per name.
// Find the sequence of fields with the name of this first field.
fi := fields[i]
name := fi.name
for advance = 1; i+advance < len(fields); advance++ {
fj := fields[i+advance]
if fj.name != name {
break
}
}
if advance == 1 { // Only one field with this name
out = append(out, fi)
continue
}
dominant, ok := dominantField(fields[i : i+advance])
if ok {
out = append(out, dominant)
}
}
fields = out
sort.Sort(byIndex(fields))
for i := range fields {
f := &fields[i]
err := enc.newTypeEncoder(typeByIndex(t, f.index), stack+pathByIndex(t, f.index))
if err != nil {
return err
}
}
return nil
}
// dominantField looks through the fields, all of which are known to
// have the same name, to find the single field that dominates the
// others using Go's embedding rules, modified by the presence of
// JSON tags. If there are multiple top-level fields, the boolean
// will be false: This condition is an error in Go and we skip all
// the fields.
func dominantField(fields []field) (field, bool) {
// The fields are sorted in increasing index-length order, then by presence of tag.
// That means that the first field is the dominant one. We need only check
// for error cases: two fields at top level, either both tagged or neither tagged.
if len(fields) > 1 && len(fields[0].index) == len(fields[1].index) && fields[0].tag == fields[1].tag {
return field{}, false
}
return fields[0], true
}
go-tools-2021.1.2/staticcheck/fakereflect/ 0000775 0000000 0000000 00000000000 14143223131 0020234 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/fakereflect/fakereflect.go 0000664 0000000 0000000 00000005207 14143223131 0023042 0 ustar 00root root 0000000 0000000 package fakereflect
import (
"fmt"
"go/types"
"reflect"
)
type TypeAndCanAddr struct {
Type types.Type
canAddr bool
}
type StructField struct {
Index []int
Name string
Anonymous bool
Tag reflect.StructTag
f *types.Var
Type TypeAndCanAddr
}
func (sf StructField) IsExported() bool { return sf.f.Exported() }
func (t TypeAndCanAddr) Field(i int) StructField {
st := t.Type.Underlying().(*types.Struct)
f := st.Field(i)
return StructField{
f: f,
Index: []int{i},
Name: f.Name(),
Anonymous: f.Anonymous(),
Tag: reflect.StructTag(st.Tag(i)),
Type: TypeAndCanAddr{
Type: f.Type(),
canAddr: t.canAddr,
},
}
}
func (t TypeAndCanAddr) FieldByIndex(index []int) StructField {
f := t.Field(index[0])
for _, idx := range index[1:] {
f = f.Type.Field(idx)
}
f.Index = index
return f
}
func PtrTo(t TypeAndCanAddr) TypeAndCanAddr {
// Note that we don't care about canAddr here because it's irrelevant to all uses of PtrTo
return TypeAndCanAddr{Type: types.NewPointer(t.Type)}
}
func (t TypeAndCanAddr) CanAddr() bool { return t.canAddr }
func (t TypeAndCanAddr) Implements(ityp *types.Interface) bool {
return types.Implements(t.Type, ityp)
}
func (t TypeAndCanAddr) IsSlice() bool {
_, ok := t.Type.Underlying().(*types.Slice)
return ok
}
func (t TypeAndCanAddr) IsArray() bool {
_, ok := t.Type.Underlying().(*types.Array)
return ok
}
func (t TypeAndCanAddr) IsPtr() bool {
_, ok := t.Type.Underlying().(*types.Pointer)
return ok
}
func (t TypeAndCanAddr) IsInterface() bool {
_, ok := t.Type.Underlying().(*types.Interface)
return ok
}
func (t TypeAndCanAddr) IsStruct() bool {
_, ok := t.Type.Underlying().(*types.Struct)
return ok
}
func (t TypeAndCanAddr) Name() string {
named, ok := t.Type.(*types.Named)
if !ok {
return ""
}
return named.Obj().Name()
}
func (t TypeAndCanAddr) NumField() int {
return t.Type.Underlying().(*types.Struct).NumFields()
}
func (t TypeAndCanAddr) String() string {
return t.Type.String()
}
func (t TypeAndCanAddr) Key() TypeAndCanAddr {
return TypeAndCanAddr{Type: t.Type.Underlying().(*types.Map).Key()}
}
func (t TypeAndCanAddr) Elem() TypeAndCanAddr {
switch typ := t.Type.Underlying().(type) {
case *types.Pointer:
return TypeAndCanAddr{
Type: typ.Elem(),
canAddr: true,
}
case *types.Slice:
return TypeAndCanAddr{
Type: typ.Elem(),
canAddr: true,
}
case *types.Array:
return TypeAndCanAddr{
Type: typ.Elem(),
canAddr: t.canAddr,
}
case *types.Map:
return TypeAndCanAddr{
Type: typ.Elem(),
canAddr: false,
}
default:
panic(fmt.Sprintf("unhandled type %T", typ))
}
}
go-tools-2021.1.2/staticcheck/fakexml/ 0000775 0000000 0000000 00000000000 14143223131 0017410 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/fakexml/marshal.go 0000664 0000000 0000000 00000021126 14143223131 0021370 0 ustar 00root root 0000000 0000000 // Copyright 2011 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 contains a modified copy of the encoding/xml encoder.
// All dynamic behavior has been removed, and reflecttion has been replaced with go/types.
// This allows us to statically find unmarshable types
// with the same rules for tags, shadowing and addressability as encoding/xml.
// This is used for SA1026 and SA5008.
// NOTE(dh): we do not check CanInterface in various places, which means we'll accept more marshaler implementations than encoding/xml does. This will lead to a small amount of false negatives.
package fakexml
import (
"fmt"
"go/token"
"go/types"
"honnef.co/go/tools/go/types/typeutil"
"honnef.co/go/tools/staticcheck/fakereflect"
)
func Marshal(v types.Type) error {
return NewEncoder().Encode(v)
}
type Encoder struct {
seen map[fakereflect.TypeAndCanAddr]struct{}
}
func NewEncoder() *Encoder {
e := &Encoder{
seen: map[fakereflect.TypeAndCanAddr]struct{}{},
}
return e
}
func (enc *Encoder) Encode(v types.Type) error {
rv := fakereflect.TypeAndCanAddr{Type: v}
return enc.marshalValue(rv, nil, nil, "x")
}
func implementsMarshaler(v fakereflect.TypeAndCanAddr) bool {
t := v.Type
named, ok := t.(*types.Named)
if !ok {
return false
}
obj, _, _ := types.LookupFieldOrMethod(named, false, nil, "MarshalXML")
if obj == nil {
return false
}
fn, ok := obj.(*types.Func)
if !ok {
return false
}
params := fn.Type().(*types.Signature).Params()
if params.Len() != 2 {
return false
}
if !typeutil.IsType(params.At(0).Type(), "*encoding/xml.Encoder") {
return false
}
if !typeutil.IsType(params.At(1).Type(), "encoding/xml.StartElement") {
return false
}
rets := fn.Type().(*types.Signature).Results()
if rets.Len() != 1 {
return false
}
if !typeutil.IsType(rets.At(0).Type(), "error") {
return false
}
return true
}
func implementsMarshalerAttr(v fakereflect.TypeAndCanAddr) bool {
t := v.Type
named, ok := t.(*types.Named)
if !ok {
return false
}
obj, _, _ := types.LookupFieldOrMethod(named, false, nil, "MarshalXMLAttr")
if obj == nil {
return false
}
fn, ok := obj.(*types.Func)
if !ok {
return false
}
params := fn.Type().(*types.Signature).Params()
if params.Len() != 1 {
return false
}
if !typeutil.IsType(params.At(0).Type(), "encoding/xml.Name") {
return false
}
rets := fn.Type().(*types.Signature).Results()
if rets.Len() != 2 {
return false
}
if !typeutil.IsType(rets.At(0).Type(), "encoding/xml.Attr") {
return false
}
if !typeutil.IsType(rets.At(1).Type(), "error") {
return false
}
return true
}
var textMarshalerType = types.NewInterfaceType([]*types.Func{
types.NewFunc(token.NoPos, nil, "MarshalText", types.NewSignature(nil,
types.NewTuple(),
types.NewTuple(
types.NewVar(token.NoPos, nil, "", types.NewSlice(types.Typ[types.Byte])),
types.NewVar(0, nil, "", types.Universe.Lookup("error").Type())),
false,
)),
}, nil).Complete()
var N = 0
// marshalValue writes one or more XML elements representing val.
// If val was obtained from a struct field, finfo must have its details.
func (e *Encoder) marshalValue(val fakereflect.TypeAndCanAddr, finfo *fieldInfo, startTemplate *StartElement, stack string) error {
if _, ok := e.seen[val]; ok {
return nil
}
e.seen[val] = struct{}{}
// Drill into interfaces and pointers.
for val.IsInterface() || val.IsPtr() {
if val.IsInterface() {
return nil
}
val = val.Elem()
}
// Check for marshaler.
if implementsMarshaler(val) {
return nil
}
if val.CanAddr() {
pv := fakereflect.PtrTo(val)
if implementsMarshaler(pv) {
return nil
}
}
// Check for text marshaler.
if val.Implements(textMarshalerType) {
return nil
}
if val.CanAddr() {
pv := fakereflect.PtrTo(val)
if pv.Implements(textMarshalerType) {
return nil
}
}
// Slices and arrays iterate over the elements. They do not have an enclosing tag.
if (val.IsSlice() || val.IsArray()) && !isByteArray(val) && !isByteSlice(val) {
if err := e.marshalValue(val.Elem(), finfo, startTemplate, stack+"[0]"); err != nil {
return err
}
return nil
}
tinfo, err := getTypeInfo(val)
if err != nil {
return err
}
// Create start element.
// Precedence for the XML element name is:
// 0. startTemplate
// 1. XMLName field in underlying struct;
// 2. field name/tag in the struct field; and
// 3. type name
var start StartElement
if startTemplate != nil {
start.Name = startTemplate.Name
start.Attr = append(start.Attr, startTemplate.Attr...)
} else if tinfo.xmlname != nil {
xmlname := tinfo.xmlname
if xmlname.name != "" {
start.Name.Space, start.Name.Local = xmlname.xmlns, xmlname.name
}
}
// Attributes
for i := range tinfo.fields {
finfo := &tinfo.fields[i]
if finfo.flags&fAttr == 0 {
continue
}
fv := finfo.value(val)
name := Name{Space: finfo.xmlns, Local: finfo.name}
if err := e.marshalAttr(&start, name, fv, stack+pathByIndex(val, finfo.idx)); err != nil {
return err
}
}
if val.IsStruct() {
return e.marshalStruct(tinfo, val, stack)
} else {
return e.marshalSimple(val, stack)
}
}
func isSlice(v fakereflect.TypeAndCanAddr) bool {
_, ok := v.Type.Underlying().(*types.Slice)
return ok
}
func isByteSlice(v fakereflect.TypeAndCanAddr) bool {
slice, ok := v.Type.Underlying().(*types.Slice)
if !ok {
return false
}
basic, ok := slice.Elem().Underlying().(*types.Basic)
if !ok {
return false
}
return basic.Kind() == types.Uint8
}
func isByteArray(v fakereflect.TypeAndCanAddr) bool {
slice, ok := v.Type.Underlying().(*types.Array)
if !ok {
return false
}
basic, ok := slice.Elem().Underlying().(*types.Basic)
if !ok {
return false
}
return basic.Kind() == types.Uint8
}
// marshalAttr marshals an attribute with the given name and value, adding to start.Attr.
func (e *Encoder) marshalAttr(start *StartElement, name Name, val fakereflect.TypeAndCanAddr, stack string) error {
if implementsMarshalerAttr(val) {
return nil
}
if val.CanAddr() {
pv := fakereflect.PtrTo(val)
if implementsMarshalerAttr(pv) {
return nil
}
}
if val.Implements(textMarshalerType) {
return nil
}
if val.CanAddr() {
pv := fakereflect.PtrTo(val)
if pv.Implements(textMarshalerType) {
return nil
}
}
// Dereference or skip nil pointer
if val.IsPtr() {
val = val.Elem()
}
// Walk slices.
if isSlice(val) && !isByteSlice(val) {
if err := e.marshalAttr(start, name, val.Elem(), stack+"[0]"); err != nil {
return err
}
return nil
}
if typeutil.IsType(val.Type, "encoding/xml.Attr") {
return nil
}
return e.marshalSimple(val, stack)
}
func (e *Encoder) marshalSimple(val fakereflect.TypeAndCanAddr, stack string) error {
switch val.Type.Underlying().(type) {
case *types.Basic, *types.Interface:
return nil
case *types.Slice, *types.Array:
basic, ok := val.Elem().Type.Underlying().(*types.Basic)
if !ok || basic.Kind() != types.Uint8 {
return &UnsupportedTypeError{val.Type, stack}
}
return nil
default:
return &UnsupportedTypeError{val.Type, stack}
}
}
func indirect(vf fakereflect.TypeAndCanAddr) fakereflect.TypeAndCanAddr {
for vf.IsPtr() {
vf = vf.Elem()
}
return vf
}
func pathByIndex(t fakereflect.TypeAndCanAddr, index []int) string {
path := ""
for _, i := range index {
if t.IsPtr() {
t = t.Elem()
}
path += "." + t.Field(i).Name
t = t.Field(i).Type
}
return path
}
func (e *Encoder) marshalStruct(tinfo *typeInfo, val fakereflect.TypeAndCanAddr, stack string) error {
for i := range tinfo.fields {
finfo := &tinfo.fields[i]
if finfo.flags&fAttr != 0 {
continue
}
vf := finfo.value(val)
switch finfo.flags & fMode {
case fCDATA, fCharData:
if vf.Implements(textMarshalerType) {
continue
}
if vf.CanAddr() {
pv := fakereflect.PtrTo(vf)
if pv.Implements(textMarshalerType) {
continue
}
}
vf = indirect(vf)
continue
case fComment:
vf = indirect(vf)
if !(isByteSlice(vf) || isByteArray(vf)) {
return fmt.Errorf("xml: bad type for comment field of %s", val)
}
continue
case fInnerXML:
vf = indirect(vf)
if typeutil.IsType(vf.Type, "[]byte") || typeutil.IsType(vf.Type, "string") {
continue
}
case fElement, fElement | fAny:
}
if err := e.marshalValue(vf, finfo, nil, stack+pathByIndex(val, finfo.idx)); err != nil {
return err
}
}
return nil
}
// UnsupportedTypeError is returned when Marshal encounters a type
// that cannot be converted into XML.
type UnsupportedTypeError struct {
Type types.Type
Path string
}
func (e *UnsupportedTypeError) Error() string {
return fmt.Sprintf("xml: unsupported type %s, via %s ", e.Type, e.Path)
}
go-tools-2021.1.2/staticcheck/fakexml/typeinfo.go 0000664 0000000 0000000 00000023520 14143223131 0021576 0 ustar 00root root 0000000 0000000 // Copyright 2011 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 fakexml
import (
"fmt"
"go/types"
"strconv"
"strings"
"sync"
"honnef.co/go/tools/staticcheck/fakereflect"
)
// typeInfo holds details for the xml representation of a type.
type typeInfo struct {
xmlname *fieldInfo
fields []fieldInfo
}
// fieldInfo holds details for the xml representation of a single field.
type fieldInfo struct {
idx []int
name string
xmlns string
flags fieldFlags
parents []string
}
type fieldFlags int
const (
fElement fieldFlags = 1 << iota
fAttr
fCDATA
fCharData
fInnerXML
fComment
fAny
fOmitEmpty
fMode = fElement | fAttr | fCDATA | fCharData | fInnerXML | fComment | fAny
xmlName = "XMLName"
)
func (f fieldFlags) String() string {
switch f {
case fAttr:
return "attr"
case fCDATA:
return "cdata"
case fCharData:
return "chardata"
case fInnerXML:
return "innerxml"
case fComment:
return "comment"
case fAny:
return "any"
case fOmitEmpty:
return "omitempty"
case fAny | fAttr:
return "any,attr"
default:
return strconv.Itoa(int(f))
}
}
var tinfoMap sync.Map // map[reflect.Type]*typeInfo
// getTypeInfo returns the typeInfo structure with details necessary
// for marshaling and unmarshaling typ.
func getTypeInfo(typ fakereflect.TypeAndCanAddr) (*typeInfo, error) {
if ti, ok := tinfoMap.Load(typ); ok {
return ti.(*typeInfo), nil
}
tinfo := &typeInfo{}
named, ok := typ.Type.(*types.Named)
if typ.IsStruct() && !(ok && named.Obj().Pkg().Path() == "encoding/xml" && named.Obj().Name() == "Name") {
n := typ.NumField()
for i := 0; i < n; i++ {
f := typ.Field(i)
if (!f.IsExported() && !f.Anonymous) || f.Tag.Get("xml") == "-" {
continue // Private field
}
// For embedded structs, embed its fields.
if f.Anonymous {
t := f.Type
if t.IsPtr() {
t = t.Elem()
}
if t.IsStruct() {
inner, err := getTypeInfo(t)
if err != nil {
return nil, err
}
if tinfo.xmlname == nil {
tinfo.xmlname = inner.xmlname
}
for _, finfo := range inner.fields {
finfo.idx = append([]int{i}, finfo.idx...)
if err := addFieldInfo(typ, tinfo, &finfo); err != nil {
return nil, err
}
}
continue
}
}
finfo, err := StructFieldInfo(f)
if err != nil {
return nil, err
}
if f.Name == xmlName {
tinfo.xmlname = finfo
continue
}
// Add the field if it doesn't conflict with other fields.
if err := addFieldInfo(typ, tinfo, finfo); err != nil {
return nil, err
}
}
}
ti, _ := tinfoMap.LoadOrStore(typ, tinfo)
return ti.(*typeInfo), nil
}
// StructFieldInfo builds and returns a fieldInfo for f.
func StructFieldInfo(f fakereflect.StructField) (*fieldInfo, error) {
finfo := &fieldInfo{idx: f.Index}
// Split the tag from the xml namespace if necessary.
tag := f.Tag.Get("xml")
if i := strings.Index(tag, " "); i >= 0 {
finfo.xmlns, tag = tag[:i], tag[i+1:]
}
// Parse flags.
tokens := strings.Split(tag, ",")
if len(tokens) == 1 {
finfo.flags = fElement
} else {
tag = tokens[0]
for _, flag := range tokens[1:] {
switch flag {
case "attr":
finfo.flags |= fAttr
case "cdata":
finfo.flags |= fCDATA
case "chardata":
finfo.flags |= fCharData
case "innerxml":
finfo.flags |= fInnerXML
case "comment":
finfo.flags |= fComment
case "any":
finfo.flags |= fAny
case "omitempty":
finfo.flags |= fOmitEmpty
}
}
// Validate the flags used.
switch mode := finfo.flags & fMode; mode {
case 0:
finfo.flags |= fElement
case fAttr, fCDATA, fCharData, fInnerXML, fComment, fAny, fAny | fAttr:
if f.Name == xmlName {
return nil, fmt.Errorf("cannot use option %s on XMLName field", mode)
} else if tag != "" && mode != fAttr {
return nil, fmt.Errorf("cannot specify name together with option ,%s", mode)
}
default:
// This will also catch multiple modes in a single field.
return nil, fmt.Errorf("invalid combination of options: %q", f.Tag.Get("xml"))
}
if finfo.flags&fMode == fAny {
finfo.flags |= fElement
}
if finfo.flags&fOmitEmpty != 0 && finfo.flags&(fElement|fAttr) == 0 {
return nil, fmt.Errorf("can only use omitempty on elements and attributes")
}
}
// Use of xmlns without a name is not allowed.
if finfo.xmlns != "" && tag == "" {
return nil, fmt.Errorf("namespace without name: %q", f.Tag.Get("xml"))
}
if f.Name == xmlName {
// The XMLName field records the XML element name. Don't
// process it as usual because its name should default to
// empty rather than to the field name.
finfo.name = tag
return finfo, nil
}
if tag == "" {
// If the name part of the tag is completely empty, get
// default from XMLName of underlying struct if feasible,
// or field name otherwise.
if xmlname := lookupXMLName(f.Type); xmlname != nil {
finfo.xmlns, finfo.name = xmlname.xmlns, xmlname.name
} else {
finfo.name = f.Name
}
return finfo, nil
}
// Prepare field name and parents.
parents := strings.Split(tag, ">")
if parents[0] == "" {
parents[0] = f.Name
}
if parents[len(parents)-1] == "" {
return nil, fmt.Errorf("trailing '>'")
}
finfo.name = parents[len(parents)-1]
if len(parents) > 1 {
if (finfo.flags & fElement) == 0 {
return nil, fmt.Errorf("%s chain not valid with %s flag", tag, strings.Join(tokens[1:], ","))
}
finfo.parents = parents[:len(parents)-1]
}
// If the field type has an XMLName field, the names must match
// so that the behavior of both marshaling and unmarshaling
// is straightforward and unambiguous.
if finfo.flags&fElement != 0 {
ftyp := f.Type
xmlname := lookupXMLName(ftyp)
if xmlname != nil && xmlname.name != finfo.name {
return nil, fmt.Errorf("name %q conflicts with name %q in %s.XMLName", finfo.name, xmlname.name, ftyp)
}
}
return finfo, nil
}
// lookupXMLName returns the fieldInfo for typ's XMLName field
// in case it exists and has a valid xml field tag, otherwise
// it returns nil.
func lookupXMLName(typ fakereflect.TypeAndCanAddr) (xmlname *fieldInfo) {
for typ.IsPtr() {
typ = typ.Elem()
}
if !typ.IsStruct() {
return nil
}
for i, n := 0, typ.NumField(); i < n; i++ {
f := typ.Field(i)
if f.Name != xmlName {
continue
}
finfo, err := StructFieldInfo(f)
if err == nil && finfo.name != "" {
return finfo
}
// Also consider errors as a non-existent field tag
// and let getTypeInfo itself report the error.
break
}
return nil
}
func min(a, b int) int {
if a <= b {
return a
}
return b
}
// addFieldInfo adds finfo to tinfo.fields if there are no
// conflicts, or if conflicts arise from previous fields that were
// obtained from deeper embedded structures than finfo. In the latter
// case, the conflicting entries are dropped.
// A conflict occurs when the path (parent + name) to a field is
// itself a prefix of another path, or when two paths match exactly.
// It is okay for field paths to share a common, shorter prefix.
func addFieldInfo(typ fakereflect.TypeAndCanAddr, tinfo *typeInfo, newf *fieldInfo) error {
var conflicts []int
Loop:
// First, figure all conflicts. Most working code will have none.
for i := range tinfo.fields {
oldf := &tinfo.fields[i]
if oldf.flags&fMode != newf.flags&fMode {
continue
}
if oldf.xmlns != "" && newf.xmlns != "" && oldf.xmlns != newf.xmlns {
continue
}
minl := min(len(newf.parents), len(oldf.parents))
for p := 0; p < minl; p++ {
if oldf.parents[p] != newf.parents[p] {
continue Loop
}
}
if len(oldf.parents) > len(newf.parents) {
if oldf.parents[len(newf.parents)] == newf.name {
conflicts = append(conflicts, i)
}
} else if len(oldf.parents) < len(newf.parents) {
if newf.parents[len(oldf.parents)] == oldf.name {
conflicts = append(conflicts, i)
}
} else {
if newf.name == oldf.name {
conflicts = append(conflicts, i)
}
}
}
// Without conflicts, add the new field and return.
if conflicts == nil {
tinfo.fields = append(tinfo.fields, *newf)
return nil
}
// If any conflict is shallower, ignore the new field.
// This matches the Go field resolution on embedding.
for _, i := range conflicts {
if len(tinfo.fields[i].idx) < len(newf.idx) {
return nil
}
}
// Otherwise, if any of them is at the same depth level, it's an error.
for _, i := range conflicts {
oldf := &tinfo.fields[i]
if len(oldf.idx) == len(newf.idx) {
f1 := typ.FieldByIndex(oldf.idx)
f2 := typ.FieldByIndex(newf.idx)
return &TagPathError{typ, f1.Name, f1.Tag.Get("xml"), f2.Name, f2.Tag.Get("xml")}
}
}
// Otherwise, the new field is shallower, and thus takes precedence,
// so drop the conflicting fields from tinfo and append the new one.
for c := len(conflicts) - 1; c >= 0; c-- {
i := conflicts[c]
copy(tinfo.fields[i:], tinfo.fields[i+1:])
tinfo.fields = tinfo.fields[:len(tinfo.fields)-1]
}
tinfo.fields = append(tinfo.fields, *newf)
return nil
}
// A TagPathError represents an error in the unmarshaling process
// caused by the use of field tags with conflicting paths.
type TagPathError struct {
Struct fakereflect.TypeAndCanAddr
Field1, Tag1 string
Field2, Tag2 string
}
func (e *TagPathError) Error() string {
return fmt.Sprintf("%s field %q with tag %q conflicts with field %q with tag %q", e.Struct, e.Field1, e.Tag1, e.Field2, e.Tag2)
}
// value returns v's field value corresponding to finfo.
// It's equivalent to v.FieldByIndex(finfo.idx), but when passed
// initNilPointers, it initializes and dereferences pointers as necessary.
// When passed dontInitNilPointers and a nil pointer is reached, the function
// returns a zero reflect.Value.
func (finfo *fieldInfo) value(v fakereflect.TypeAndCanAddr) fakereflect.TypeAndCanAddr {
for i, x := range finfo.idx {
if i > 0 {
t := v
if t.IsPtr() && t.Elem().IsStruct() {
v = v.Elem()
}
}
v = v.Field(x).Type
}
return v
}
go-tools-2021.1.2/staticcheck/fakexml/xml.go 0000664 0000000 0000000 00000001536 14143223131 0020544 0 ustar 00root root 0000000 0000000 // Copyright 2009 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 fakexml
// References:
// Annotated XML spec: https://www.xml.com/axml/testaxml.htm
// XML name spaces: https://www.w3.org/TR/REC-xml-names/
// TODO(rsc):
// Test error handling.
// A Name represents an XML name (Local) annotated
// with a name space identifier (Space).
// In tokens returned by Decoder.Token, the Space identifier
// is given as a canonical URL, not the short prefix used
// in the document being parsed.
type Name struct {
Space, Local string
}
// An Attr represents an attribute in an XML element (Name=Value).
type Attr struct {
Name Name
Value string
}
// A StartElement represents an XML start element.
type StartElement struct {
Name Name
Attr []Attr
}
go-tools-2021.1.2/staticcheck/lint.go 0000664 0000000 0000000 00000412561 14143223131 0017267 0 ustar 00root root 0000000 0000000 // Package staticcheck contains a linter for Go source code.
package staticcheck
import (
"fmt"
"go/ast"
"go/constant"
"go/token"
"go/types"
htmltemplate "html/template"
"net/http"
"reflect"
"regexp"
"regexp/syntax"
"sort"
"strconv"
"strings"
texttemplate "text/template"
"unicode"
"honnef.co/go/tools/analysis/code"
"honnef.co/go/tools/analysis/edit"
"honnef.co/go/tools/analysis/facts"
"honnef.co/go/tools/analysis/facts/nilness"
"honnef.co/go/tools/analysis/facts/typedness"
"honnef.co/go/tools/analysis/lint"
"honnef.co/go/tools/analysis/report"
"honnef.co/go/tools/go/ast/astutil"
"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"
"honnef.co/go/tools/internal/sharedcheck"
"honnef.co/go/tools/knowledge"
"honnef.co/go/tools/pattern"
"honnef.co/go/tools/printf"
"honnef.co/go/tools/staticcheck/fakejson"
"honnef.co/go/tools/staticcheck/fakereflect"
"honnef.co/go/tools/staticcheck/fakexml"
"golang.org/x/tools/go/analysis"
"golang.org/x/tools/go/analysis/passes/inspect"
"golang.org/x/tools/go/ast/inspector"
)
func checkSortSlice(call *Call) {
c := call.Instr.Common().StaticCallee()
arg := call.Args[0]
T := arg.Value.Value.Type().Underlying()
switch T.(type) {
case *types.Interface:
// we don't know.
// TODO(dh): if the value is a phi node we can look at its edges
if k, ok := arg.Value.Value.(*ir.Const); ok && k.Value == nil {
// literal nil, e.g. sort.Sort(nil, ...)
arg.Invalid(fmt.Sprintf("cannot call %s on nil literal", c))
}
case *types.Slice:
// this is fine
default:
// this is not fine
arg.Invalid(fmt.Sprintf("%s must only be called on slices, was called on %s", c, T))
}
}
func validRegexp(call *Call) {
arg := call.Args[0]
err := ValidateRegexp(arg.Value)
if err != nil {
arg.Invalid(err.Error())
}
}
type runeSlice []rune
func (rs runeSlice) Len() int { return len(rs) }
func (rs runeSlice) Less(i int, j int) bool { return rs[i] < rs[j] }
func (rs runeSlice) Swap(i int, j int) { rs[i], rs[j] = rs[j], rs[i] }
func utf8Cutset(call *Call) {
arg := call.Args[1]
if InvalidUTF8(arg.Value) {
arg.Invalid(MsgInvalidUTF8)
}
}
func uniqueCutset(call *Call) {
arg := call.Args[1]
if !UniqueStringCutset(arg.Value) {
arg.Invalid(MsgNonUniqueCutset)
}
}
func unmarshalPointer(name string, arg int) CallCheck {
return func(call *Call) {
if !Pointer(call.Args[arg].Value) {
call.Args[arg].Invalid(fmt.Sprintf("%s expects to unmarshal into a pointer, but the provided value is not a pointer", name))
}
}
}
func pointlessIntMath(call *Call) {
if ConvertedFromInt(call.Args[0].Value) {
call.Invalid(fmt.Sprintf("calling %s on a converted integer is pointless", irutil.CallName(call.Instr.Common())))
}
}
func checkValidHostPort(arg int) CallCheck {
return func(call *Call) {
if !ValidHostPort(call.Args[arg].Value) {
call.Args[arg].Invalid(MsgInvalidHostPort)
}
}
}
var (
checkRegexpRules = map[string]CallCheck{
"regexp.MustCompile": validRegexp,
"regexp.Compile": validRegexp,
"regexp.Match": validRegexp,
"regexp.MatchReader": validRegexp,
"regexp.MatchString": validRegexp,
}
checkTimeParseRules = map[string]CallCheck{
"time.Parse": func(call *Call) {
arg := call.Args[knowledge.Arg("time.Parse.layout")]
err := ValidateTimeLayout(arg.Value)
if err != nil {
arg.Invalid(err.Error())
}
},
}
checkEncodingBinaryRules = map[string]CallCheck{
"encoding/binary.Write": func(call *Call) {
arg := call.Args[knowledge.Arg("encoding/binary.Write.data")]
if !CanBinaryMarshal(call.Pass, arg.Value) {
arg.Invalid(fmt.Sprintf("value of type %s cannot be used with binary.Write", arg.Value.Value.Type()))
}
},
}
checkURLsRules = map[string]CallCheck{
"net/url.Parse": func(call *Call) {
arg := call.Args[knowledge.Arg("net/url.Parse.rawurl")]
err := ValidateURL(arg.Value)
if err != nil {
arg.Invalid(err.Error())
}
},
}
checkSyncPoolValueRules = map[string]CallCheck{
"(*sync.Pool).Put": func(call *Call) {
arg := call.Args[knowledge.Arg("(*sync.Pool).Put.x")]
typ := arg.Value.Value.Type()
_, isSlice := typ.Underlying().(*types.Slice)
if !typeutil.IsPointerLike(typ) || isSlice {
arg.Invalid("argument should be pointer-like to avoid allocations")
}
},
}
checkRegexpFindAllRules = map[string]CallCheck{
"(*regexp.Regexp).FindAll": RepeatZeroTimes("a FindAll method", 1),
"(*regexp.Regexp).FindAllIndex": RepeatZeroTimes("a FindAll method", 1),
"(*regexp.Regexp).FindAllString": RepeatZeroTimes("a FindAll method", 1),
"(*regexp.Regexp).FindAllStringIndex": RepeatZeroTimes("a FindAll method", 1),
"(*regexp.Regexp).FindAllStringSubmatch": RepeatZeroTimes("a FindAll method", 1),
"(*regexp.Regexp).FindAllStringSubmatchIndex": RepeatZeroTimes("a FindAll method", 1),
"(*regexp.Regexp).FindAllSubmatch": RepeatZeroTimes("a FindAll method", 1),
"(*regexp.Regexp).FindAllSubmatchIndex": RepeatZeroTimes("a FindAll method", 1),
}
checkUTF8CutsetRules = map[string]CallCheck{
"strings.IndexAny": utf8Cutset,
"strings.LastIndexAny": utf8Cutset,
"strings.ContainsAny": utf8Cutset,
"strings.Trim": utf8Cutset,
"strings.TrimLeft": utf8Cutset,
"strings.TrimRight": utf8Cutset,
}
checkUniqueCutsetRules = map[string]CallCheck{
"strings.Trim": uniqueCutset,
"strings.TrimLeft": uniqueCutset,
"strings.TrimRight": uniqueCutset,
}
checkUnmarshalPointerRules = map[string]CallCheck{
"encoding/xml.Unmarshal": unmarshalPointer("xml.Unmarshal", 1),
"(*encoding/xml.Decoder).Decode": unmarshalPointer("Decode", 0),
"(*encoding/xml.Decoder).DecodeElement": unmarshalPointer("DecodeElement", 0),
"encoding/json.Unmarshal": unmarshalPointer("json.Unmarshal", 1),
"(*encoding/json.Decoder).Decode": unmarshalPointer("Decode", 0),
}
checkUnbufferedSignalChanRules = map[string]CallCheck{
"os/signal.Notify": func(call *Call) {
arg := call.Args[knowledge.Arg("os/signal.Notify.c")]
if UnbufferedChannel(arg.Value) {
arg.Invalid("the channel used with signal.Notify should be buffered")
}
},
}
checkMathIntRules = map[string]CallCheck{
"math.Ceil": pointlessIntMath,
"math.Floor": pointlessIntMath,
"math.IsNaN": pointlessIntMath,
"math.Trunc": pointlessIntMath,
"math.IsInf": pointlessIntMath,
}
checkStringsReplaceZeroRules = map[string]CallCheck{
"strings.Replace": RepeatZeroTimes("strings.Replace", 3),
"bytes.Replace": RepeatZeroTimes("bytes.Replace", 3),
}
checkListenAddressRules = map[string]CallCheck{
"net/http.ListenAndServe": checkValidHostPort(0),
"net/http.ListenAndServeTLS": checkValidHostPort(0),
}
checkBytesEqualIPRules = map[string]CallCheck{
"bytes.Equal": func(call *Call) {
if ConvertedFrom(call.Args[knowledge.Arg("bytes.Equal.a")].Value, "net.IP") &&
ConvertedFrom(call.Args[knowledge.Arg("bytes.Equal.b")].Value, "net.IP") {
call.Invalid("use net.IP.Equal to compare net.IPs, not bytes.Equal")
}
},
}
checkRegexpMatchLoopRules = map[string]CallCheck{
"regexp.Match": loopedRegexp("regexp.Match"),
"regexp.MatchReader": loopedRegexp("regexp.MatchReader"),
"regexp.MatchString": loopedRegexp("regexp.MatchString"),
}
checkNoopMarshal = map[string]CallCheck{
// TODO(dh): should we really flag XML? Even an empty struct
// produces a non-zero amount of data, namely its type name.
// Let's see if we encounter any false positives.
//
// Also, should we flag gob?
"encoding/json.Marshal": checkNoopMarshalImpl(knowledge.Arg("json.Marshal.v"), "MarshalJSON", "MarshalText"),
"encoding/xml.Marshal": checkNoopMarshalImpl(knowledge.Arg("xml.Marshal.v"), "MarshalXML", "MarshalText"),
"(*encoding/json.Encoder).Encode": checkNoopMarshalImpl(knowledge.Arg("(*encoding/json.Encoder).Encode.v"), "MarshalJSON", "MarshalText"),
"(*encoding/xml.Encoder).Encode": checkNoopMarshalImpl(knowledge.Arg("(*encoding/xml.Encoder).Encode.v"), "MarshalXML", "MarshalText"),
"encoding/json.Unmarshal": checkNoopMarshalImpl(knowledge.Arg("json.Unmarshal.v"), "UnmarshalJSON", "UnmarshalText"),
"encoding/xml.Unmarshal": checkNoopMarshalImpl(knowledge.Arg("xml.Unmarshal.v"), "UnmarshalXML", "UnmarshalText"),
"(*encoding/json.Decoder).Decode": checkNoopMarshalImpl(knowledge.Arg("(*encoding/json.Decoder).Decode.v"), "UnmarshalJSON", "UnmarshalText"),
"(*encoding/xml.Decoder).Decode": checkNoopMarshalImpl(knowledge.Arg("(*encoding/xml.Decoder).Decode.v"), "UnmarshalXML", "UnmarshalText"),
}
checkUnsupportedMarshal = map[string]CallCheck{
"encoding/json.Marshal": checkUnsupportedMarshalJSON,
"encoding/xml.Marshal": checkUnsupportedMarshalXML,
"(*encoding/json.Encoder).Encode": checkUnsupportedMarshalJSON,
"(*encoding/xml.Encoder).Encode": checkUnsupportedMarshalXML,
}
checkAtomicAlignment = map[string]CallCheck{
"sync/atomic.AddInt64": checkAtomicAlignmentImpl,
"sync/atomic.AddUint64": checkAtomicAlignmentImpl,
"sync/atomic.CompareAndSwapInt64": checkAtomicAlignmentImpl,
"sync/atomic.CompareAndSwapUint64": checkAtomicAlignmentImpl,
"sync/atomic.LoadInt64": checkAtomicAlignmentImpl,
"sync/atomic.LoadUint64": checkAtomicAlignmentImpl,
"sync/atomic.StoreInt64": checkAtomicAlignmentImpl,
"sync/atomic.StoreUint64": checkAtomicAlignmentImpl,
"sync/atomic.SwapInt64": checkAtomicAlignmentImpl,
"sync/atomic.SwapUint64": checkAtomicAlignmentImpl,
}
// TODO(dh): detect printf wrappers
checkPrintfRules = map[string]CallCheck{
"fmt.Errorf": func(call *Call) { checkPrintfCall(call, 0, 1) },
"fmt.Printf": func(call *Call) { checkPrintfCall(call, 0, 1) },
"fmt.Sprintf": func(call *Call) { checkPrintfCall(call, 0, 1) },
"fmt.Fprintf": func(call *Call) { checkPrintfCall(call, 1, 2) },
"golang.org/x/xerrors.Errorf": func(call *Call) { checkPrintfCall(call, 0, 1) },
}
checkSortSliceRules = map[string]CallCheck{
"sort.Slice": checkSortSlice,
"sort.SliceIsSorted": checkSortSlice,
"sort.SliceStable": checkSortSlice,
}
checkWithValueKeyRules = map[string]CallCheck{
"context.WithValue": checkWithValueKey,
}
checkStrconvRules = map[string]CallCheck{
"strconv.ParseComplex": func(call *Call) {
validateComplexBitSize(call.Args[knowledge.Arg("strconv.ParseComplex.bitSize")])
},
"strconv.ParseFloat": func(call *Call) {
validateFloatBitSize(call.Args[knowledge.Arg("strconv.ParseFloat.bitSize")])
},
"strconv.ParseInt": func(call *Call) {
validateContinuousBitSize(call.Args[knowledge.Arg("strconv.ParseInt.bitSize")], 0, 64)
validateIntBaseAllowZero(call.Args[knowledge.Arg("strconv.ParseInt.base")])
},
"strconv.ParseUint": func(call *Call) {
validateContinuousBitSize(call.Args[knowledge.Arg("strconv.ParseUint.bitSize")], 0, 64)
validateIntBaseAllowZero(call.Args[knowledge.Arg("strconv.ParseUint.base")])
},
"strconv.FormatComplex": func(call *Call) {
validateComplexFormat(call.Args[knowledge.Arg("strconv.FormatComplex.fmt")])
validateComplexBitSize(call.Args[knowledge.Arg("strconv.FormatComplex.bitSize")])
},
"strconv.FormatFloat": func(call *Call) {
validateFloatFormat(call.Args[knowledge.Arg("strconv.FormatFloat.fmt")])
validateFloatBitSize(call.Args[knowledge.Arg("strconv.FormatFloat.bitSize")])
},
"strconv.FormatInt": func(call *Call) {
validateIntBase(call.Args[knowledge.Arg("strconv.FormatInt.base")])
},
"strconv.FormatUint": func(call *Call) {
validateIntBase(call.Args[knowledge.Arg("strconv.FormatUint.base")])
},
"strconv.AppendFloat": func(call *Call) {
validateFloatFormat(call.Args[knowledge.Arg("strconv.AppendFloat.fmt")])
validateFloatBitSize(call.Args[knowledge.Arg("strconv.AppendFloat.bitSize")])
},
"strconv.AppendInt": func(call *Call) {
validateIntBase(call.Args[knowledge.Arg("strconv.AppendInt.base")])
},
"strconv.AppendUint": func(call *Call) {
validateIntBase(call.Args[knowledge.Arg("strconv.AppendUint.base")])
},
}
)
func validateIntBase(arg *Argument) {
if c := extractConstExpectKind(arg.Value.Value, constant.Int); c != nil {
val, _ := constant.Int64Val(c.Value)
if val < 2 {
arg.Invalid("'base' must not be smaller than 2")
}
if val > 36 {
arg.Invalid("'base' must not be larger than 36")
}
}
}
func validateIntBaseAllowZero(arg *Argument) {
if c := extractConstExpectKind(arg.Value.Value, constant.Int); c != nil {
val, _ := constant.Int64Val(c.Value)
if val < 2 && val != 0 {
arg.Invalid("'base' must not be smaller than 2, unless it is 0")
}
if val > 36 {
arg.Invalid("'base' must not be larger than 36")
}
}
}
func validateComplexFormat(arg *Argument) {
validateFloatFormat(arg)
}
func validateFloatFormat(arg *Argument) {
if c := extractConstExpectKind(arg.Value.Value, constant.Int); c != nil {
val, _ := constant.Int64Val(c.Value)
switch val {
case 'b', 'e', 'E', 'f', 'g', 'G', 'x', 'X':
default:
arg.Invalid(fmt.Sprintf("'fmt' argument is invalid: unknown format %q", val))
}
}
}
func validateComplexBitSize(arg *Argument) { validateDiscreetBitSize(arg, 64, 128) }
func validateFloatBitSize(arg *Argument) { validateDiscreetBitSize(arg, 32, 64) }
func validateDiscreetBitSize(arg *Argument, size1 int, size2 int) {
if c := extractConstExpectKind(arg.Value.Value, constant.Int); c != nil {
val, _ := constant.Int64Val(c.Value)
if val != int64(size1) && val != int64(size2) {
arg.Invalid(fmt.Sprintf("'bitSize' argument is invalid, must be either %d or %d", size1, size2))
}
}
}
func validateContinuousBitSize(arg *Argument, min int, max int) {
if c := extractConstExpectKind(arg.Value.Value, constant.Int); c != nil {
val, _ := constant.Int64Val(c.Value)
if val < int64(min) || val > int64(max) {
arg.Invalid(fmt.Sprintf("'bitSize' argument is invalid, must be within %d and %d", min, max))
}
}
}
func checkPrintfCall(call *Call, fIdx, vIdx int) {
f := call.Args[fIdx]
var args []ir.Value
switch v := call.Args[vIdx].Value.Value.(type) {
case *ir.Slice:
var ok bool
args, ok = irutil.Vararg(v)
if !ok {
// We don't know what the actual arguments to the function are
return
}
case *ir.Const:
// nil, i.e. no arguments
default:
// We don't know what the actual arguments to the function are
return
}
checkPrintfCallImpl(f, f.Value.Value, args)
}
type verbFlag int
const (
isInt verbFlag = 1 << iota
isBool
isFP
isString
isPointer
// Verbs that accept "pseudo pointers" will sometimes dereference
// non-nil pointers. For example, %x on a non-nil *struct will print the
// individual fields, but on a nil pointer it will print the address.
isPseudoPointer
isSlice
isAny
noRecurse
)
var verbs = [...]verbFlag{
'b': isPseudoPointer | isInt | isFP,
'c': isInt,
'd': isPseudoPointer | isInt,
'e': isFP,
'E': isFP,
'f': isFP,
'F': isFP,
'g': isFP,
'G': isFP,
'o': isPseudoPointer | isInt,
'O': isPseudoPointer | isInt,
'p': isSlice | isPointer | noRecurse,
'q': isInt | isString,
's': isString,
't': isBool,
'T': isAny,
'U': isInt,
'v': isAny,
'X': isPseudoPointer | isInt | isFP | isString,
'x': isPseudoPointer | isInt | isFP | isString,
}
func checkPrintfCallImpl(carg *Argument, f ir.Value, args []ir.Value) {
var msCache *typeutil.MethodSetCache
if f.Parent() != nil {
msCache = &f.Parent().Prog.MethodSets
}
elem := func(T types.Type, verb rune) ([]types.Type, bool) {
if verbs[verb]&noRecurse != 0 {
return []types.Type{T}, false
}
switch T := T.(type) {
case *types.Slice:
if verbs[verb]&isSlice != 0 {
return []types.Type{T}, false
}
if verbs[verb]&isString != 0 && typeutil.IsType(T.Elem().Underlying(), "byte") {
return []types.Type{T}, false
}
return []types.Type{T.Elem()}, true
case *types.Map:
key := T.Key()
val := T.Elem()
return []types.Type{key, val}, true
case *types.Struct:
out := make([]types.Type, 0, T.NumFields())
for i := 0; i < T.NumFields(); i++ {
out = append(out, T.Field(i).Type())
}
return out, true
case *types.Array:
return []types.Type{T.Elem()}, true
default:
return []types.Type{T}, false
}
}
isInfo := func(T types.Type, info types.BasicInfo) bool {
basic, ok := T.Underlying().(*types.Basic)
return ok && basic.Info()&info != 0
}
isStringer := func(T types.Type, ms *types.MethodSet) bool {
sel := ms.Lookup(nil, "String")
if sel == nil {
return false
}
fn, ok := sel.Obj().(*types.Func)
if !ok {
// should be unreachable
return false
}
sig := fn.Type().(*types.Signature)
if sig.Params().Len() != 0 {
return false
}
if sig.Results().Len() != 1 {
return false
}
if !typeutil.IsType(sig.Results().At(0).Type(), "string") {
return false
}
return true
}
isError := func(T types.Type, ms *types.MethodSet) bool {
sel := ms.Lookup(nil, "Error")
if sel == nil {
return false
}
fn, ok := sel.Obj().(*types.Func)
if !ok {
// should be unreachable
return false
}
sig := fn.Type().(*types.Signature)
if sig.Params().Len() != 0 {
return false
}
if sig.Results().Len() != 1 {
return false
}
if !typeutil.IsType(sig.Results().At(0).Type(), "string") {
return false
}
return true
}
isFormatter := func(T types.Type, ms *types.MethodSet) bool {
sel := ms.Lookup(nil, "Format")
if sel == nil {
return false
}
fn, ok := sel.Obj().(*types.Func)
if !ok {
// should be unreachable
return false
}
sig := fn.Type().(*types.Signature)
if sig.Params().Len() != 2 {
return false
}
// TODO(dh): check the types of the arguments for more
// precision
if sig.Results().Len() != 0 {
return false
}
return true
}
seen := map[types.Type]bool{}
var checkType func(verb rune, T types.Type, top bool) bool
checkType = func(verb rune, T types.Type, top bool) bool {
if top {
for k := range seen {
delete(seen, k)
}
}
if seen[T] {
return true
}
seen[T] = true
if int(verb) >= len(verbs) {
// Unknown verb
return true
}
flags := verbs[verb]
if flags == 0 {
// Unknown verb
return true
}
ms := msCache.MethodSet(T)
if isFormatter(T, ms) {
// the value is responsible for formatting itself
return true
}
if flags&isString != 0 && (isStringer(T, ms) || isError(T, ms)) {
// Check for stringer early because we're about to dereference
return true
}
T = T.Underlying()
if flags&(isPointer|isPseudoPointer) == 0 && top {
T = typeutil.Dereference(T)
}
if flags&isPseudoPointer != 0 && top {
t := typeutil.Dereference(T)
if _, ok := t.Underlying().(*types.Struct); ok {
T = t
}
}
if _, ok := T.(*types.Interface); ok {
// We don't know what's in the interface
return true
}
var info types.BasicInfo
if flags&isInt != 0 {
info |= types.IsInteger
}
if flags&isBool != 0 {
info |= types.IsBoolean
}
if flags&isFP != 0 {
info |= types.IsFloat | types.IsComplex
}
if flags&isString != 0 {
info |= types.IsString
}
if info != 0 && isInfo(T, info) {
return true
}
if flags&isString != 0 {
isStringyElem := func(typ types.Type) bool {
if typ, ok := typ.Underlying().(*types.Basic); ok {
return typ.Kind() == types.Byte
}
return false
}
switch T := T.(type) {
case *types.Slice:
if isStringyElem(T.Elem()) {
return true
}
case *types.Array:
if isStringyElem(T.Elem()) {
return true
}
}
if isStringer(T, ms) || isError(T, ms) {
return true
}
}
if flags&isPointer != 0 && typeutil.IsPointerLike(T) {
return true
}
if flags&isPseudoPointer != 0 {
switch U := T.Underlying().(type) {
case *types.Pointer:
if !top {
return true
}
if _, ok := U.Elem().Underlying().(*types.Struct); !ok {
// TODO(dh): can this condition ever be false? For
// *T, if T is a struct, we'll already have
// dereferenced it, meaning the *types.Pointer
// branch couldn't have been taken. For T that
// aren't structs, this condition will always
// evaluate to true.
return true
}
case *types.Chan, *types.Signature:
// Channels and functions are always treated as
// pointers and never recursed into.
return true
case *types.Basic:
if U.Kind() == types.UnsafePointer {
return true
}
case *types.Interface:
// we will already have bailed if the type is an
// interface.
panic("unreachable")
default:
// other pointer-like types, such as maps or slices,
// will be printed element-wise.
}
}
if flags&isSlice != 0 {
if _, ok := T.(*types.Slice); ok {
return true
}
}
if flags&isAny != 0 {
return true
}
elems, ok := elem(T.Underlying(), verb)
if !ok {
return false
}
for _, elem := range elems {
if !checkType(verb, elem, false) {
return false
}
}
return true
}
k, ok := irutil.Flatten(f).(*ir.Const)
if !ok {
return
}
actions, err := printf.Parse(constant.StringVal(k.Value))
if err != nil {
carg.Invalid("couldn't parse format string")
return
}
ptr := 1
hasExplicit := false
checkStar := func(verb printf.Verb, star printf.Argument) bool {
if star, ok := star.(printf.Star); ok {
idx := 0
if star.Index == -1 {
idx = ptr
ptr++
} else {
hasExplicit = true
idx = star.Index
ptr = star.Index + 1
}
if idx == 0 {
carg.Invalid(fmt.Sprintf("Printf format %s reads invalid arg 0; indices are 1-based", verb.Raw))
return false
}
if idx > len(args) {
carg.Invalid(
fmt.Sprintf("Printf format %s reads arg #%d, but call has only %d args",
verb.Raw, idx, len(args)))
return false
}
if arg, ok := args[idx-1].(*ir.MakeInterface); ok {
if !isInfo(arg.X.Type(), types.IsInteger) {
carg.Invalid(fmt.Sprintf("Printf format %s reads non-int arg #%d as argument of *", verb.Raw, idx))
}
}
}
return true
}
// We only report one problem per format string. Making a
// mistake with an index tends to invalidate all future
// implicit indices.
for _, action := range actions {
verb, ok := action.(printf.Verb)
if !ok {
continue
}
if !checkStar(verb, verb.Width) || !checkStar(verb, verb.Precision) {
return
}
off := ptr
if verb.Value != -1 {
hasExplicit = true
off = verb.Value
}
if off > len(args) {
carg.Invalid(
fmt.Sprintf("Printf format %s reads arg #%d, but call has only %d args",
verb.Raw, off, len(args)))
return
} else if verb.Value == 0 && verb.Letter != '%' {
carg.Invalid(fmt.Sprintf("Printf format %s reads invalid arg 0; indices are 1-based", verb.Raw))
return
} else if off != 0 {
arg, ok := args[off-1].(*ir.MakeInterface)
if ok {
if !checkType(verb.Letter, arg.X.Type(), true) {
carg.Invalid(fmt.Sprintf("Printf format %s has arg #%d of wrong type %s",
verb.Raw, ptr, args[ptr-1].(*ir.MakeInterface).X.Type()))
return
}
}
}
switch verb.Value {
case -1:
// Consume next argument
ptr++
case 0:
// Don't consume any arguments
default:
ptr = verb.Value + 1
}
}
if !hasExplicit && ptr <= len(args) {
carg.Invalid(fmt.Sprintf("Printf call needs %d args but has %d args", ptr-1, len(args)))
}
}
func checkAtomicAlignmentImpl(call *Call) {
sizes := call.Pass.TypesSizes
if sizes.Sizeof(types.Typ[types.Uintptr]) != 4 {
// Not running on a 32-bit platform
return
}
v, ok := irutil.Flatten(call.Args[0].Value.Value).(*ir.FieldAddr)
if !ok {
// TODO(dh): also check indexing into arrays and slices
return
}
T := v.X.Type().Underlying().(*types.Pointer).Elem().Underlying().(*types.Struct)
fields := make([]*types.Var, 0, T.NumFields())
for i := 0; i < T.NumFields() && i <= v.Field; i++ {
fields = append(fields, T.Field(i))
}
off := sizes.Offsetsof(fields)[v.Field]
if off%8 != 0 {
msg := fmt.Sprintf("address of non 64-bit aligned field %s passed to %s",
T.Field(v.Field).Name(),
irutil.CallName(call.Instr.Common()))
call.Invalid(msg)
}
}
func checkNoopMarshalImpl(argN int, meths ...string) CallCheck {
return func(call *Call) {
if code.IsGenerated(call.Pass, call.Instr.Pos()) {
return
}
arg := call.Args[argN]
T := arg.Value.Value.Type()
Ts, ok := typeutil.Dereference(T).Underlying().(*types.Struct)
if !ok {
return
}
if Ts.NumFields() == 0 {
return
}
fields := typeutil.FlattenFields(Ts)
for _, field := range fields {
if field.Var.Exported() {
return
}
}
// OPT(dh): we could use a method set cache here
ms := call.Instr.Parent().Prog.MethodSets.MethodSet(T)
// TODO(dh): we're not checking the signature, which can cause false negatives.
// This isn't a huge problem, however, since vet complains about incorrect signatures.
for _, meth := range meths {
if ms.Lookup(nil, meth) != nil {
return
}
}
arg.Invalid(fmt.Sprintf("struct type '%s' doesn't have any exported fields, nor custom marshaling", typeutil.Dereference(T)))
}
}
func checkUnsupportedMarshalJSON(call *Call) {
arg := call.Args[0]
T := arg.Value.Value.Type()
if err := fakejson.Marshal(T); err != nil {
typ := types.TypeString(err.Type, types.RelativeTo(arg.Value.Value.Parent().Pkg.Pkg))
if err.Path == "x" {
arg.Invalid(fmt.Sprintf("trying to marshal unsupported type %s", typ))
} else {
arg.Invalid(fmt.Sprintf("trying to marshal unsupported type %s, via %s", typ, err.Path))
}
}
}
func checkUnsupportedMarshalXML(call *Call) {
arg := call.Args[0]
T := arg.Value.Value.Type()
if err := fakexml.Marshal(T); err != nil {
switch err := err.(type) {
case *fakexml.UnsupportedTypeError:
typ := types.TypeString(err.Type, types.RelativeTo(arg.Value.Value.Parent().Pkg.Pkg))
if err.Path == "x" {
arg.Invalid(fmt.Sprintf("trying to marshal unsupported type %s", typ))
} else {
arg.Invalid(fmt.Sprintf("trying to marshal unsupported type %s, via %s", typ, err.Path))
}
case *fakexml.TagPathError:
// Vet does a better job at reporting this error, because it can flag the actual struct tags, not just the call to Marshal
default:
// These errors get reported by SA5008 instead, which can flag the actual fields, independently of calls to xml.Marshal
}
}
}
func isInLoop(b *ir.BasicBlock) bool {
sets := irutil.FindLoops(b.Parent())
for _, set := range sets {
if set.Has(b) {
return true
}
}
return false
}
func CheckUntrappableSignal(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
call := node.(*ast.CallExpr)
if !code.IsCallToAny(pass, call,
"os/signal.Ignore", "os/signal.Notify", "os/signal.Reset") {
return
}
hasSigterm := false
for _, arg := range call.Args {
if conv, ok := arg.(*ast.CallExpr); ok && isName(pass, conv.Fun, "os.Signal") {
arg = conv.Args[0]
}
if isName(pass, arg, "syscall.SIGTERM") {
hasSigterm = true
break
}
}
for i, arg := range call.Args {
if conv, ok := arg.(*ast.CallExpr); ok && isName(pass, conv.Fun, "os.Signal") {
arg = conv.Args[0]
}
if isName(pass, arg, "os.Kill") || isName(pass, arg, "syscall.SIGKILL") {
var fixes []analysis.SuggestedFix
if !hasSigterm {
nargs := make([]ast.Expr, len(call.Args))
for j, a := range call.Args {
if i == j {
nargs[j] = edit.Selector("syscall", "SIGTERM")
} else {
nargs[j] = a
}
}
ncall := *call
ncall.Args = nargs
fixes = append(fixes, edit.Fix(fmt.Sprintf("use syscall.SIGTERM instead of %s", report.Render(pass, arg)), edit.ReplaceWithNode(pass.Fset, call, &ncall)))
}
nargs := make([]ast.Expr, 0, len(call.Args))
for j, a := range call.Args {
if i == j {
continue
}
nargs = append(nargs, a)
}
ncall := *call
ncall.Args = nargs
fixes = append(fixes, edit.Fix(fmt.Sprintf("remove %s from list of arguments", report.Render(pass, arg)), edit.ReplaceWithNode(pass.Fset, call, &ncall)))
report.Report(pass, arg, fmt.Sprintf("%s cannot be trapped (did you mean syscall.SIGTERM?)", report.Render(pass, arg)), report.Fixes(fixes...))
}
if isName(pass, arg, "syscall.SIGSTOP") {
nargs := make([]ast.Expr, 0, len(call.Args)-1)
for j, a := range call.Args {
if i == j {
continue
}
nargs = append(nargs, a)
}
ncall := *call
ncall.Args = nargs
report.Report(pass, arg, "syscall.SIGSTOP cannot be trapped", report.Fixes(edit.Fix("remove syscall.SIGSTOP from list of arguments", edit.ReplaceWithNode(pass.Fset, call, &ncall))))
}
}
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
func CheckTemplate(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
call := node.(*ast.CallExpr)
// OPT(dh): use integer for kind
var kind string
switch code.CallName(pass, call) {
case "(*text/template.Template).Parse":
kind = "text"
case "(*html/template.Template).Parse":
kind = "html"
default:
return
}
sel := call.Fun.(*ast.SelectorExpr)
if !code.IsCallToAny(pass, sel.X, "text/template.New", "html/template.New") {
// TODO(dh): this is a cheap workaround for templates with
// different delims. A better solution with less false
// negatives would use data flow analysis to see where the
// template comes from and where it has been
return
}
s, ok := code.ExprToString(pass, call.Args[knowledge.Arg("(*text/template.Template).Parse.text")])
if !ok {
return
}
var err error
switch kind {
case "text":
_, err = texttemplate.New("").Parse(s)
case "html":
_, err = htmltemplate.New("").Parse(s)
}
if err != nil {
// TODO(dominikh): whitelist other parse errors, if any
if strings.Contains(err.Error(), "unexpected") {
report.Report(pass, call.Args[knowledge.Arg("(*text/template.Template).Parse.text")], err.Error())
}
}
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
var (
checkTimeSleepConstantPatternRns = pattern.MustParse(`(BinaryExpr duration "*" (SelectorExpr (Ident "time") (Ident "Nanosecond")))`)
checkTimeSleepConstantPatternRs = pattern.MustParse(`(BinaryExpr duration "*" (SelectorExpr (Ident "time") (Ident "Second")))`)
)
func CheckTimeSleepConstant(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
call := node.(*ast.CallExpr)
if !code.IsCallTo(pass, call, "time.Sleep") {
return
}
lit, ok := call.Args[knowledge.Arg("time.Sleep.d")].(*ast.BasicLit)
if !ok {
return
}
n, err := strconv.Atoi(lit.Value)
if err != nil {
return
}
if n == 0 || n > 120 {
// time.Sleep(0) is a seldom used pattern in concurrency
// tests. >120 might be intentional. 120 was chosen
// because the user could've meant 2 minutes.
return
}
report.Report(pass, lit,
fmt.Sprintf("sleeping for %d nanoseconds is probably a bug; be explicit if it isn't", n), report.Fixes(
edit.Fix("explicitly use nanoseconds", edit.ReplaceWithPattern(pass, checkTimeSleepConstantPatternRns, pattern.State{"duration": lit}, lit)),
edit.Fix("use seconds", edit.ReplaceWithPattern(pass, checkTimeSleepConstantPatternRs, pattern.State{"duration": lit}, lit))))
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
var checkWaitgroupAddQ = pattern.MustParse(`
(GoStmt
(CallExpr
(FuncLit
_
call@(CallExpr (Function "(*sync.WaitGroup).Add") _):_) _))`)
func CheckWaitgroupAdd(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
if m, ok := code.Match(pass, checkWaitgroupAddQ, node); ok {
call := m.State["call"].(ast.Node)
report.Report(pass, call, fmt.Sprintf("should call %s before starting the goroutine to avoid a race", report.Render(pass, call)))
}
}
code.Preorder(pass, fn, (*ast.GoStmt)(nil))
return nil, nil
}
func CheckInfiniteEmptyLoop(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
loop := node.(*ast.ForStmt)
if len(loop.Body.List) != 0 || loop.Post != nil {
return
}
if loop.Init != nil {
// TODO(dh): this isn't strictly necessary, it just makes
// the check easier.
return
}
// An empty loop is bad news in two cases: 1) The loop has no
// condition. In that case, it's just a loop that spins
// forever and as fast as it can, keeping a core busy. 2) The
// loop condition only consists of variable or field reads and
// operators on those. The only way those could change their
// value is with unsynchronised access, which constitutes a
// data race.
//
// If the condition contains any function calls, its behaviour
// is dynamic and the loop might terminate. Similarly for
// channel receives.
if loop.Cond != nil {
if code.MayHaveSideEffects(pass, loop.Cond, nil) {
return
}
if ident, ok := loop.Cond.(*ast.Ident); ok {
if k, ok := pass.TypesInfo.ObjectOf(ident).(*types.Const); ok {
if !constant.BoolVal(k.Val()) {
// don't flag `for false {}` loops. They're a debug aid.
return
}
}
}
report.Report(pass, loop, "loop condition never changes or has a race condition")
}
report.Report(pass, loop, "this loop will spin, using 100% CPU", report.ShortRange())
}
code.Preorder(pass, fn, (*ast.ForStmt)(nil))
return nil, nil
}
func CheckDeferInInfiniteLoop(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
mightExit := false
var defers []ast.Stmt
loop := node.(*ast.ForStmt)
if loop.Cond != nil {
return
}
fn2 := func(node ast.Node) bool {
switch stmt := node.(type) {
case *ast.ReturnStmt:
mightExit = true
return false
case *ast.BranchStmt:
// TODO(dominikh): if this sees a break in a switch or
// select, it doesn't check if it breaks the loop or
// just the select/switch. This causes some false
// negatives.
if stmt.Tok == token.BREAK {
mightExit = true
return false
}
case *ast.DeferStmt:
defers = append(defers, stmt)
case *ast.FuncLit:
// Don't look into function bodies
return false
}
return true
}
ast.Inspect(loop.Body, fn2)
if mightExit {
return
}
for _, stmt := range defers {
report.Report(pass, stmt, "defers in this infinite loop will never run")
}
}
code.Preorder(pass, fn, (*ast.ForStmt)(nil))
return nil, nil
}
func CheckDubiousDeferInChannelRangeLoop(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
loop := node.(*ast.RangeStmt)
typ := pass.TypesInfo.TypeOf(loop.X)
_, ok := typ.Underlying().(*types.Chan)
if !ok {
return
}
fn2 := func(node ast.Node) bool {
switch stmt := node.(type) {
case *ast.DeferStmt:
report.Report(pass, stmt, "defers in this range loop won't run unless the channel gets closed")
case *ast.FuncLit:
// Don't look into function bodies
return false
}
return true
}
ast.Inspect(loop.Body, fn2)
}
code.Preorder(pass, fn, (*ast.RangeStmt)(nil))
return nil, nil
}
func CheckTestMainExit(pass *analysis.Pass) (interface{}, error) {
if code.IsGoVersion(pass, 15) {
// Beginning with Go 1.15, the test framework will call
// os.Exit for us.
return nil, nil
}
var (
fnmain ast.Node
callsExit bool
callsRun bool
arg types.Object
)
fn := func(node ast.Node, push bool) bool {
if !push {
if fnmain != nil && node == fnmain {
if !callsExit && callsRun {
report.Report(pass, fnmain, "TestMain should call os.Exit to set exit code")
}
fnmain = nil
callsExit = false
callsRun = false
arg = nil
}
return true
}
switch node := node.(type) {
case *ast.FuncDecl:
if fnmain != nil {
return true
}
if !isTestMain(pass, node) {
return false
}
fnmain = node
arg = pass.TypesInfo.ObjectOf(node.Type.Params.List[0].Names[0])
return true
case *ast.CallExpr:
if code.IsCallTo(pass, node, "os.Exit") {
callsExit = true
return false
}
sel, ok := node.Fun.(*ast.SelectorExpr)
if !ok {
return true
}
ident, ok := sel.X.(*ast.Ident)
if !ok {
return true
}
if arg != pass.TypesInfo.ObjectOf(ident) {
return true
}
if sel.Sel.Name == "Run" {
callsRun = true
return false
}
return true
default:
lint.ExhaustiveTypeSwitch(node)
return true
}
}
pass.ResultOf[inspect.Analyzer].(*inspector.Inspector).Nodes([]ast.Node{(*ast.FuncDecl)(nil), (*ast.CallExpr)(nil)}, fn)
return nil, nil
}
func isTestMain(pass *analysis.Pass, decl *ast.FuncDecl) bool {
if decl.Name.Name != "TestMain" {
return false
}
if len(decl.Type.Params.List) != 1 {
return false
}
arg := decl.Type.Params.List[0]
if len(arg.Names) != 1 {
return false
}
return code.IsOfType(pass, arg.Type, "*testing.M")
}
func CheckExec(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
call := node.(*ast.CallExpr)
if !code.IsCallTo(pass, call, "os/exec.Command") {
return
}
val, ok := code.ExprToString(pass, call.Args[knowledge.Arg("os/exec.Command.name")])
if !ok {
return
}
if !strings.Contains(val, " ") || strings.Contains(val, `\`) || strings.Contains(val, "/") {
return
}
report.Report(pass, call.Args[knowledge.Arg("os/exec.Command.name")],
"first argument to exec.Command looks like a shell command, but a program name or path are expected")
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
func CheckLoopEmptyDefault(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
loop := node.(*ast.ForStmt)
if len(loop.Body.List) != 1 || loop.Cond != nil || loop.Init != nil {
return
}
sel, ok := loop.Body.List[0].(*ast.SelectStmt)
if !ok {
return
}
for _, c := range sel.Body.List {
// FIXME this leaves behind an empty line, and possibly
// comments in the default branch. We can't easily fix
// either.
if comm, ok := c.(*ast.CommClause); ok && comm.Comm == nil && len(comm.Body) == 0 {
report.Report(pass, comm, "should not have an empty default case in a for+select loop; the loop will spin",
report.Fixes(edit.Fix("remove empty default branch", edit.Delete(comm))))
// there can only be one default case
break
}
}
}
code.Preorder(pass, fn, (*ast.ForStmt)(nil))
return nil, nil
}
func CheckLhsRhsIdentical(pass *analysis.Pass) (interface{}, error) {
var isFloat func(T types.Type) bool
isFloat = func(T types.Type) bool {
switch T := T.Underlying().(type) {
case *types.Basic:
kind := T.Kind()
return kind == types.Float32 || kind == types.Float64
case *types.Array:
return isFloat(T.Elem())
case *types.Struct:
for i := 0; i < T.NumFields(); i++ {
if !isFloat(T.Field(i).Type()) {
return false
}
}
return true
default:
return false
}
}
// TODO(dh): this check ignores the existence of side-effects and
// happily flags fn() == fn() β so far, we've had nobody complain
// about a false positive, and it's caught several bugs in real
// code.
//
// We special case functions from the math/rand package. Someone ran
// into the following false positive: "rand.Intn(2) - rand.Intn(2), which I wrote to generate values {-1, 0, 1} with {0.25, 0.5, 0.25} probability."
fn := func(node ast.Node) {
op := node.(*ast.BinaryExpr)
switch op.Op {
case token.EQL, token.NEQ:
case token.SUB, token.QUO, token.AND, token.REM, token.OR, token.XOR, token.AND_NOT,
token.LAND, token.LOR, token.LSS, token.GTR, token.LEQ, token.GEQ:
default:
// For some ops, such as + and *, it can make sense to
// have identical operands
return
}
if isFloat(pass.TypesInfo.TypeOf(op.X)) {
// 'float float' makes sense for several operators.
// We've tried keeping an exact list of operators to allow, but floats keep surprising us. Let's just give up instead.
return
}
if reflect.TypeOf(op.X) != reflect.TypeOf(op.Y) {
return
}
if report.Render(pass, op.X) != report.Render(pass, op.Y) {
return
}
l1, ok1 := op.X.(*ast.BasicLit)
l2, ok2 := op.Y.(*ast.BasicLit)
if ok1 && ok2 && l1.Kind == token.INT && l2.Kind == l1.Kind && l1.Value == "0" && l2.Value == l1.Value && code.IsGenerated(pass, l1.Pos()) {
// cgo generates the following function call:
// _cgoCheckPointer(_cgoBase0, 0 == 0) β it uses 0 == 0
// instead of true in case the user shadowed the
// identifier. Ideally we'd restrict this exception to
// calls of _cgoCheckPointer, but it's not worth the
// hassle of keeping track of the stack.
// are very rare to begin with, and we're mostly checking
// for them to catch typos such as 1 == 1 where the user
// meant to type i == 1. The odds of a false negative for
// 0 == 0 are slim.
return
}
if expr, ok := op.X.(*ast.CallExpr); ok {
call := code.CallName(pass, expr)
switch call {
case "math/rand.Int",
"math/rand.Int31",
"math/rand.Int31n",
"math/rand.Int63",
"math/rand.Int63n",
"math/rand.Intn",
"math/rand.Uint32",
"math/rand.Uint64",
"math/rand.ExpFloat64",
"math/rand.Float32",
"math/rand.Float64",
"math/rand.NormFloat64",
"(*math/rand.Rand).Int",
"(*math/rand.Rand).Int31",
"(*math/rand.Rand).Int31n",
"(*math/rand.Rand).Int63",
"(*math/rand.Rand).Int63n",
"(*math/rand.Rand).Intn",
"(*math/rand.Rand).Uint32",
"(*math/rand.Rand).Uint64",
"(*math/rand.Rand).ExpFloat64",
"(*math/rand.Rand).Float32",
"(*math/rand.Rand).Float64",
"(*math/rand.Rand).NormFloat64":
return
}
}
report.Report(pass, op, fmt.Sprintf("identical expressions on the left and right side of the '%s' operator", op.Op))
}
code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
return nil, nil
}
func CheckScopedBreak(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
var body *ast.BlockStmt
switch node := node.(type) {
case *ast.ForStmt:
body = node.Body
case *ast.RangeStmt:
body = node.Body
default:
lint.ExhaustiveTypeSwitch(node)
}
for _, stmt := range body.List {
var blocks [][]ast.Stmt
switch stmt := stmt.(type) {
case *ast.SwitchStmt:
for _, c := range stmt.Body.List {
blocks = append(blocks, c.(*ast.CaseClause).Body)
}
case *ast.SelectStmt:
for _, c := range stmt.Body.List {
blocks = append(blocks, c.(*ast.CommClause).Body)
}
default:
continue
}
for _, body := range blocks {
if len(body) == 0 {
continue
}
lasts := []ast.Stmt{body[len(body)-1]}
// TODO(dh): unfold all levels of nested block
// statements, not just a single level if statement
if ifs, ok := lasts[0].(*ast.IfStmt); ok {
if len(ifs.Body.List) == 0 {
continue
}
lasts[0] = ifs.Body.List[len(ifs.Body.List)-1]
if block, ok := ifs.Else.(*ast.BlockStmt); ok {
if len(block.List) != 0 {
lasts = append(lasts, block.List[len(block.List)-1])
}
}
}
for _, last := range lasts {
branch, ok := last.(*ast.BranchStmt)
if !ok || branch.Tok != token.BREAK || branch.Label != nil {
continue
}
report.Report(pass, branch, "ineffective break statement. Did you mean to break out of the outer loop?")
}
}
}
}
code.Preorder(pass, fn, (*ast.ForStmt)(nil), (*ast.RangeStmt)(nil))
return nil, nil
}
func CheckUnsafePrintf(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
call := node.(*ast.CallExpr)
name := code.CallName(pass, call)
var arg int
switch name {
case "fmt.Printf", "fmt.Sprintf", "log.Printf":
arg = knowledge.Arg("fmt.Printf.format")
case "fmt.Fprintf":
arg = knowledge.Arg("fmt.Fprintf.format")
default:
return
}
if len(call.Args) != arg+1 {
return
}
switch call.Args[arg].(type) {
case *ast.CallExpr, *ast.Ident:
default:
return
}
if _, ok := pass.TypesInfo.TypeOf(call.Args[arg]).(*types.Tuple); ok {
// the called function returns multiple values and got
// splatted into the call. for all we know, it is
// returning good arguments.
return
}
alt := name[:len(name)-1]
report.Report(pass, call,
"printf-style function with dynamic format string and no further arguments should use print-style function instead",
report.Fixes(edit.Fix(fmt.Sprintf("use %s instead of %s", alt, name), edit.ReplaceWithString(pass.Fset, call.Fun, alt))))
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
func CheckEarlyDefer(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
block := node.(*ast.BlockStmt)
if len(block.List) < 2 {
return
}
for i, stmt := range block.List {
if i == len(block.List)-1 {
break
}
assign, ok := stmt.(*ast.AssignStmt)
if !ok {
continue
}
if len(assign.Rhs) != 1 {
continue
}
if len(assign.Lhs) < 2 {
continue
}
if lhs, ok := assign.Lhs[len(assign.Lhs)-1].(*ast.Ident); ok && lhs.Name == "_" {
continue
}
call, ok := assign.Rhs[0].(*ast.CallExpr)
if !ok {
continue
}
sig, ok := pass.TypesInfo.TypeOf(call.Fun).(*types.Signature)
if !ok {
continue
}
if sig.Results().Len() < 2 {
continue
}
last := sig.Results().At(sig.Results().Len() - 1)
// FIXME(dh): check that it's error from universe, not
// another type of the same name
if last.Type().String() != "error" {
continue
}
lhs, ok := assign.Lhs[0].(*ast.Ident)
if !ok {
continue
}
def, ok := block.List[i+1].(*ast.DeferStmt)
if !ok {
continue
}
sel, ok := def.Call.Fun.(*ast.SelectorExpr)
if !ok {
continue
}
ident, ok := selectorX(sel).(*ast.Ident)
if !ok {
continue
}
if ident.Obj != lhs.Obj {
continue
}
if sel.Sel.Name != "Close" {
continue
}
report.Report(pass, def, fmt.Sprintf("should check returned error before deferring %s", report.Render(pass, def.Call)))
}
}
code.Preorder(pass, fn, (*ast.BlockStmt)(nil))
return nil, nil
}
func selectorX(sel *ast.SelectorExpr) ast.Node {
switch x := sel.X.(type) {
case *ast.SelectorExpr:
return selectorX(x)
default:
return x
}
}
func CheckEmptyCriticalSection(pass *analysis.Pass) (interface{}, error) {
if pass.Pkg.Path() == "sync_test" {
// exception for the sync package's tests
return nil, nil
}
// Initially it might seem like this check would be easier to
// implement using IR. After all, we're only checking for two
// consecutive method calls. In reality, however, there may be any
// number of other instructions between the lock and unlock, while
// still constituting an empty critical section. For example,
// given `m.x().Lock(); m.x().Unlock()`, there will be a call to
// x(). In the AST-based approach, this has a tiny potential for a
// false positive (the second call to x might be doing work that
// is protected by the mutex). In an IR-based approach, however,
// it would miss a lot of real bugs.
mutexParams := func(s ast.Stmt) (x ast.Expr, funcName string, ok bool) {
expr, ok := s.(*ast.ExprStmt)
if !ok {
return nil, "", false
}
call, ok := expr.X.(*ast.CallExpr)
if !ok {
return nil, "", false
}
sel, ok := call.Fun.(*ast.SelectorExpr)
if !ok {
return nil, "", false
}
fn, ok := pass.TypesInfo.ObjectOf(sel.Sel).(*types.Func)
if !ok {
return nil, "", false
}
sig := fn.Type().(*types.Signature)
if sig.Params().Len() != 0 || sig.Results().Len() != 0 {
return nil, "", false
}
return sel.X, fn.Name(), true
}
fn := func(node ast.Node) {
block := node.(*ast.BlockStmt)
if len(block.List) < 2 {
return
}
for i := range block.List[:len(block.List)-1] {
sel1, method1, ok1 := mutexParams(block.List[i])
sel2, method2, ok2 := mutexParams(block.List[i+1])
if !ok1 || !ok2 || report.Render(pass, sel1) != report.Render(pass, sel2) {
continue
}
if (method1 == "Lock" && method2 == "Unlock") ||
(method1 == "RLock" && method2 == "RUnlock") {
report.Report(pass, block.List[i+1], "empty critical section")
}
}
}
code.Preorder(pass, fn, (*ast.BlockStmt)(nil))
return nil, nil
}
var (
// cgo produces code like fn(&*_Cvar_kSomeCallbacks) which we don't
// want to flag.
cgoIdent = regexp.MustCompile(`^_C(func|var)_.+$`)
checkIneffectiveCopyQ1 = pattern.MustParse(`(UnaryExpr "&" (StarExpr obj))`)
checkIneffectiveCopyQ2 = pattern.MustParse(`(StarExpr (UnaryExpr "&" _))`)
)
func CheckIneffectiveCopy(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
if m, ok := code.Match(pass, checkIneffectiveCopyQ1, node); ok {
if ident, ok := m.State["obj"].(*ast.Ident); !ok || !cgoIdent.MatchString(ident.Name) {
report.Report(pass, node, "&*x will be simplified to x. It will not copy x.")
}
} else if _, ok := code.Match(pass, checkIneffectiveCopyQ2, node); ok {
report.Report(pass, node, "*&x will be simplified to x. It will not copy x.")
}
}
code.Preorder(pass, fn, (*ast.UnaryExpr)(nil), (*ast.StarExpr)(nil))
return nil, nil
}
func CheckCanonicalHeaderKey(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node, push bool) bool {
if !push {
return false
}
if assign, ok := node.(*ast.AssignStmt); ok {
// TODO(dh): This risks missing some Header reads, for
// example in `h1["foo"] = h2["foo"]` β these edge
// cases are probably rare enough to ignore for now.
for _, expr := range assign.Lhs {
op, ok := expr.(*ast.IndexExpr)
if !ok {
continue
}
if code.IsOfType(pass, op.X, "net/http.Header") {
return false
}
}
return true
}
op, ok := node.(*ast.IndexExpr)
if !ok {
return true
}
if !code.IsOfType(pass, op.X, "net/http.Header") {
return true
}
s, ok := code.ExprToString(pass, op.Index)
if !ok {
return true
}
canonical := http.CanonicalHeaderKey(s)
if s == canonical {
return true
}
var fix analysis.SuggestedFix
switch op.Index.(type) {
case *ast.BasicLit:
fix = edit.Fix("canonicalize header key", edit.ReplaceWithString(pass.Fset, op.Index, strconv.Quote(canonical)))
case *ast.Ident:
call := &ast.CallExpr{
Fun: edit.Selector("http", "CanonicalHeaderKey"),
Args: []ast.Expr{op.Index},
}
fix = edit.Fix("wrap in http.CanonicalHeaderKey", edit.ReplaceWithNode(pass.Fset, op.Index, call))
}
msg := fmt.Sprintf("keys in http.Header are canonicalized, %q is not canonical; fix the constant or use http.CanonicalHeaderKey", s)
if fix.Message != "" {
report.Report(pass, op, msg, report.Fixes(fix))
} else {
report.Report(pass, op, msg)
}
return true
}
pass.ResultOf[inspect.Analyzer].(*inspector.Inspector).Nodes([]ast.Node{(*ast.AssignStmt)(nil), (*ast.IndexExpr)(nil)}, fn)
return nil, nil
}
func CheckBenchmarkN(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
assign := node.(*ast.AssignStmt)
if len(assign.Lhs) != 1 || len(assign.Rhs) != 1 {
return
}
sel, ok := assign.Lhs[0].(*ast.SelectorExpr)
if !ok {
return
}
if sel.Sel.Name != "N" {
return
}
if !code.IsOfType(pass, sel.X, "*testing.B") {
return
}
report.Report(pass, assign, fmt.Sprintf("should not assign to %s", report.Render(pass, sel)))
}
code.Preorder(pass, fn, (*ast.AssignStmt)(nil))
return nil, nil
}
func CheckUnreadVariableValues(pass *analysis.Pass) (interface{}, error) {
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
if irutil.IsExample(fn) {
continue
}
node := fn.Source()
if node == nil {
continue
}
if gen, ok := code.Generator(pass, node.Pos()); ok && gen == facts.Goyacc {
// Don't flag unused values in code generated by goyacc.
// There may be hundreds of those due to the way the state
// machine is constructed.
continue
}
switchTags := map[ir.Value]struct{}{}
ast.Inspect(node, func(node ast.Node) bool {
s, ok := node.(*ast.SwitchStmt)
if !ok {
return true
}
v, _ := fn.ValueForExpr(s.Tag)
switchTags[v] = struct{}{}
return true
})
// OPT(dh): don't use a map, possibly use a bitset
var hasUse func(v ir.Value, seen map[ir.Value]struct{}) bool
hasUse = func(v ir.Value, seen map[ir.Value]struct{}) bool {
if _, ok := seen[v]; ok {
return false
}
if _, ok := switchTags[v]; ok {
return true
}
refs := v.Referrers()
if refs == nil {
// TODO investigate why refs can be nil
return true
}
for _, ref := range *refs {
switch ref := ref.(type) {
case *ir.DebugRef:
case *ir.Sigma:
if seen == nil {
seen = map[ir.Value]struct{}{}
}
seen[v] = struct{}{}
if hasUse(ref, seen) {
return true
}
case *ir.Phi:
if seen == nil {
seen = map[ir.Value]struct{}{}
}
seen[v] = struct{}{}
if hasUse(ref, seen) {
return true
}
default:
return true
}
}
return false
}
ast.Inspect(node, func(node ast.Node) bool {
assign, ok := node.(*ast.AssignStmt)
if !ok {
return true
}
if len(assign.Lhs) > 1 && len(assign.Rhs) == 1 {
// Either a function call with multiple return values,
// or a comma-ok assignment
val, _ := fn.ValueForExpr(assign.Rhs[0])
if val == nil {
return true
}
refs := val.Referrers()
if refs == nil {
return true
}
for _, ref := range *refs {
ex, ok := ref.(*ir.Extract)
if !ok {
continue
}
if !hasUse(ex, nil) {
lhs := assign.Lhs[ex.Index]
if ident, ok := lhs.(*ast.Ident); !ok || ok && ident.Name == "_" {
continue
}
report.Report(pass, assign, fmt.Sprintf("this value of %s is never used", lhs))
}
}
return true
}
for i, lhs := range assign.Lhs {
rhs := assign.Rhs[i]
if ident, ok := lhs.(*ast.Ident); !ok || ok && ident.Name == "_" {
continue
}
val, _ := fn.ValueForExpr(rhs)
if val == nil {
continue
}
if _, ok := val.(*ir.Const); ok {
// a zero-valued constant, for example in 'foo := []string(nil)'
continue
}
if !hasUse(val, nil) {
report.Report(pass, assign, fmt.Sprintf("this value of %s is never used", lhs))
}
}
return true
})
}
return nil, nil
}
func CheckPredeterminedBooleanExprs(pass *analysis.Pass) (interface{}, error) {
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
for _, block := range fn.Blocks {
for _, ins := range block.Instrs {
binop, ok := ins.(*ir.BinOp)
if !ok {
continue
}
switch binop.Op {
case token.GTR, token.LSS, token.EQL, token.NEQ, token.LEQ, token.GEQ:
default:
continue
}
xs, ok1 := consts(binop.X, nil, nil)
ys, ok2 := consts(binop.Y, nil, nil)
if !ok1 || !ok2 || len(xs) == 0 || len(ys) == 0 {
continue
}
trues := 0
for _, x := range xs {
for _, y := range ys {
if x.Value == nil {
if y.Value == nil {
trues++
}
continue
}
if constant.Compare(x.Value, binop.Op, y.Value) {
trues++
}
}
}
b := trues != 0
if trues == 0 || trues == len(xs)*len(ys) {
report.Report(pass, binop, fmt.Sprintf("binary expression is always %t for all possible values (%s %s %s)", b, xs, binop.Op, ys))
}
}
}
}
return nil, nil
}
func CheckNilMaps(pass *analysis.Pass) (interface{}, error) {
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
for _, block := range fn.Blocks {
for _, ins := range block.Instrs {
mu, ok := ins.(*ir.MapUpdate)
if !ok {
continue
}
c, ok := irutil.Flatten(mu.Map).(*ir.Const)
if !ok {
continue
}
if c.Value != nil {
continue
}
report.Report(pass, mu, "assignment to nil map")
}
}
}
return nil, nil
}
func CheckExtremeComparison(pass *analysis.Pass) (interface{}, error) {
isobj := func(expr ast.Expr, name string) bool {
sel, ok := expr.(*ast.SelectorExpr)
if !ok {
return false
}
return typeutil.IsObject(pass.TypesInfo.ObjectOf(sel.Sel), name)
}
fn := func(node ast.Node) {
expr := node.(*ast.BinaryExpr)
tx := pass.TypesInfo.TypeOf(expr.X)
basic, ok := tx.Underlying().(*types.Basic)
if !ok {
return
}
var max string
var min string
switch basic.Kind() {
case types.Uint8:
max = "math.MaxUint8"
case types.Uint16:
max = "math.MaxUint16"
case types.Uint32:
max = "math.MaxUint32"
case types.Uint64:
max = "math.MaxUint64"
case types.Uint:
max = "math.MaxUint64"
case types.Int8:
min = "math.MinInt8"
max = "math.MaxInt8"
case types.Int16:
min = "math.MinInt16"
max = "math.MaxInt16"
case types.Int32:
min = "math.MinInt32"
max = "math.MaxInt32"
case types.Int64:
min = "math.MinInt64"
max = "math.MaxInt64"
case types.Int:
min = "math.MinInt64"
max = "math.MaxInt64"
}
if (expr.Op == token.GTR || expr.Op == token.GEQ) && isobj(expr.Y, max) ||
(expr.Op == token.LSS || expr.Op == token.LEQ) && isobj(expr.X, max) {
report.Report(pass, expr, fmt.Sprintf("no value of type %s is greater than %s", basic, max))
}
if expr.Op == token.LEQ && isobj(expr.Y, max) ||
expr.Op == token.GEQ && isobj(expr.X, max) {
report.Report(pass, expr, fmt.Sprintf("every value of type %s is <= %s", basic, max))
}
if (basic.Info() & types.IsUnsigned) != 0 {
if (expr.Op == token.LSS && astutil.IsIntLiteral(expr.Y, "0")) ||
(expr.Op == token.GTR && astutil.IsIntLiteral(expr.X, "0")) {
report.Report(pass, expr, fmt.Sprintf("no value of type %s is less than 0", basic))
}
if expr.Op == token.GEQ && astutil.IsIntLiteral(expr.Y, "0") ||
expr.Op == token.LEQ && astutil.IsIntLiteral(expr.X, "0") {
report.Report(pass, expr, fmt.Sprintf("every value of type %s is >= 0", basic))
}
} else {
if (expr.Op == token.LSS || expr.Op == token.LEQ) && isobj(expr.Y, min) ||
(expr.Op == token.GTR || expr.Op == token.GEQ) && isobj(expr.X, min) {
report.Report(pass, expr, fmt.Sprintf("no value of type %s is less than %s", basic, min))
}
if expr.Op == token.GEQ && isobj(expr.Y, min) ||
expr.Op == token.LEQ && isobj(expr.X, min) {
report.Report(pass, expr, fmt.Sprintf("every value of type %s is >= %s", basic, min))
}
}
}
code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
return nil, nil
}
func consts(val ir.Value, out []*ir.Const, visitedPhis map[string]bool) ([]*ir.Const, bool) {
if visitedPhis == nil {
visitedPhis = map[string]bool{}
}
var ok bool
switch val := val.(type) {
case *ir.Phi:
if visitedPhis[val.Name()] {
break
}
visitedPhis[val.Name()] = true
vals := val.Operands(nil)
for _, phival := range vals {
out, ok = consts(*phival, out, visitedPhis)
if !ok {
return nil, false
}
}
case *ir.Const:
out = append(out, val)
case *ir.Convert:
out, ok = consts(val.X, out, visitedPhis)
if !ok {
return nil, false
}
default:
return nil, false
}
if len(out) < 2 {
return out, true
}
uniq := []*ir.Const{out[0]}
for _, val := range out[1:] {
if val.Value == uniq[len(uniq)-1].Value {
continue
}
uniq = append(uniq, val)
}
return uniq, true
}
func CheckLoopCondition(pass *analysis.Pass) (interface{}, error) {
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
cb := func(node ast.Node) bool {
loop, ok := node.(*ast.ForStmt)
if !ok {
return true
}
if loop.Init == nil || loop.Cond == nil || loop.Post == nil {
return true
}
init, ok := loop.Init.(*ast.AssignStmt)
if !ok || len(init.Lhs) != 1 || len(init.Rhs) != 1 {
return true
}
cond, ok := loop.Cond.(*ast.BinaryExpr)
if !ok {
return true
}
x, ok := cond.X.(*ast.Ident)
if !ok {
return true
}
lhs, ok := init.Lhs[0].(*ast.Ident)
if !ok {
return true
}
if x.Obj != lhs.Obj {
return true
}
if _, ok := loop.Post.(*ast.IncDecStmt); !ok {
return true
}
v, isAddr := fn.ValueForExpr(cond.X)
if v == nil || isAddr {
return true
}
switch v := v.(type) {
case *ir.Phi:
ops := v.Operands(nil)
if len(ops) != 2 {
return true
}
_, ok := (*ops[0]).(*ir.Const)
if !ok {
return true
}
sigma, ok := (*ops[1]).(*ir.Sigma)
if !ok {
return true
}
if sigma.X != v {
return true
}
case *ir.Load:
return true
}
report.Report(pass, cond, "variable in loop condition never changes")
return true
}
if source := fn.Source(); source != nil {
ast.Inspect(source, cb)
}
}
return nil, nil
}
func CheckArgOverwritten(pass *analysis.Pass) (interface{}, error) {
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
cb := func(node ast.Node) bool {
var typ *ast.FuncType
var body *ast.BlockStmt
switch fn := node.(type) {
case *ast.FuncDecl:
typ = fn.Type
body = fn.Body
case *ast.FuncLit:
typ = fn.Type
body = fn.Body
}
if body == nil {
return true
}
if len(typ.Params.List) == 0 {
return true
}
for _, field := range typ.Params.List {
for _, arg := range field.Names {
obj := pass.TypesInfo.ObjectOf(arg)
var irobj *ir.Parameter
for _, param := range fn.Params {
if param.Object() == obj {
irobj = param
break
}
}
if irobj == nil {
continue
}
refs := irobj.Referrers()
if refs == nil {
continue
}
if len(irutil.FilterDebug(*refs)) != 0 {
continue
}
var assignment ast.Node
ast.Inspect(body, func(node ast.Node) bool {
if assignment != nil {
return false
}
assign, ok := node.(*ast.AssignStmt)
if !ok {
return true
}
for _, lhs := range assign.Lhs {
ident, ok := lhs.(*ast.Ident)
if !ok {
continue
}
if pass.TypesInfo.ObjectOf(ident) == obj {
assignment = assign
return false
}
}
return true
})
if assignment != nil {
report.Report(pass, arg, fmt.Sprintf("argument %s is overwritten before first use", arg),
report.Related(assignment, fmt.Sprintf("assignment to %s", arg)))
}
}
}
return true
}
if source := fn.Source(); source != nil {
ast.Inspect(source, cb)
}
}
return nil, nil
}
func CheckIneffectiveLoop(pass *analysis.Pass) (interface{}, error) {
// This check detects some, but not all unconditional loop exits.
// We give up in the following cases:
//
// - a goto anywhere in the loop. The goto might skip over our
// return, and we don't check that it doesn't.
//
// - any nested, unlabelled continue, even if it is in another
// loop or closure.
fn := func(node ast.Node) {
var body *ast.BlockStmt
switch fn := node.(type) {
case *ast.FuncDecl:
body = fn.Body
case *ast.FuncLit:
body = fn.Body
default:
lint.ExhaustiveTypeSwitch(node)
}
if body == nil {
return
}
labels := map[*ast.Object]ast.Stmt{}
ast.Inspect(body, func(node ast.Node) bool {
label, ok := node.(*ast.LabeledStmt)
if !ok {
return true
}
labels[label.Label.Obj] = label.Stmt
return true
})
ast.Inspect(body, func(node ast.Node) bool {
var loop ast.Node
var body *ast.BlockStmt
switch node := node.(type) {
case *ast.ForStmt:
body = node.Body
loop = node
case *ast.RangeStmt:
typ := pass.TypesInfo.TypeOf(node.X)
if _, ok := typ.Underlying().(*types.Map); ok {
// looping once over a map is a valid pattern for
// getting an arbitrary element.
return true
}
body = node.Body
loop = node
default:
return true
}
if len(body.List) < 2 {
// TODO(dh): is this check needed? when body.List < 2,
// then we can't find both an unconditional exit and a
// branching statement (if, ...). and we don't flag
// unconditional exits if there has been no branching
// in the loop body.
// avoid flagging the somewhat common pattern of using
// a range loop to get the first element in a slice,
// or the first rune in a string.
return true
}
var unconditionalExit ast.Node
hasBranching := false
for _, stmt := range body.List {
switch stmt := stmt.(type) {
case *ast.BranchStmt:
switch stmt.Tok {
case token.BREAK:
if stmt.Label == nil || labels[stmt.Label.Obj] == loop {
unconditionalExit = stmt
}
case token.CONTINUE:
if stmt.Label == nil || labels[stmt.Label.Obj] == loop {
unconditionalExit = nil
return false
}
}
case *ast.ReturnStmt:
unconditionalExit = stmt
case *ast.IfStmt, *ast.ForStmt, *ast.RangeStmt, *ast.SwitchStmt, *ast.SelectStmt:
hasBranching = true
}
}
if unconditionalExit == nil || !hasBranching {
return false
}
ast.Inspect(body, func(node ast.Node) bool {
if branch, ok := node.(*ast.BranchStmt); ok {
switch branch.Tok {
case token.GOTO:
unconditionalExit = nil
return false
case token.CONTINUE:
if branch.Label != nil && labels[branch.Label.Obj] != loop {
return true
}
unconditionalExit = nil
return false
}
}
return true
})
if unconditionalExit != nil {
report.Report(pass, unconditionalExit, "the surrounding loop is unconditionally terminated")
}
return true
})
}
code.Preorder(pass, fn, (*ast.FuncDecl)(nil), (*ast.FuncLit)(nil))
return nil, nil
}
var checkNilContextQ = pattern.MustParse(`(CallExpr fun@(Function _) (Builtin "nil"):_)`)
func CheckNilContext(pass *analysis.Pass) (interface{}, error) {
todo := &ast.CallExpr{
Fun: edit.Selector("context", "TODO"),
}
bg := &ast.CallExpr{
Fun: edit.Selector("context", "Background"),
}
fn := func(node ast.Node) {
m, ok := code.Match(pass, checkNilContextQ, node)
if !ok {
return
}
call := node.(*ast.CallExpr)
fun, ok := m.State["fun"].(*types.Func)
if !ok {
// it might also be a builtin
return
}
sig := fun.Type().(*types.Signature)
if sig.Params().Len() == 0 {
// Our CallExpr might've matched a method expression, like
// (*T).Foo(nil) β here, nil isn't the first argument of
// the Foo method, but the method receiver.
return
}
if !typeutil.IsType(sig.Params().At(0).Type(), "context.Context") {
return
}
report.Report(pass, call.Args[0],
"do not pass a nil Context, even if a function permits it; pass context.TODO if you are unsure about which Context to use", report.Fixes(
edit.Fix("use context.TODO", edit.ReplaceWithNode(pass.Fset, call.Args[0], todo)),
edit.Fix("use context.Background", edit.ReplaceWithNode(pass.Fset, call.Args[0], bg))))
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
var (
checkSeekerQ = pattern.MustParse(`(CallExpr fun@(SelectorExpr _ (Ident "Seek")) [arg1@(SelectorExpr (Ident "io") (Ident (Or "SeekStart" "SeekCurrent" "SeekEnd"))) arg2])`)
checkSeekerR = pattern.MustParse(`(CallExpr fun [arg2 arg1])`)
)
func CheckSeeker(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
if _, edits, ok := code.MatchAndEdit(pass, checkSeekerQ, checkSeekerR, node); ok {
report.Report(pass, node, "the first argument of io.Seeker is the offset, but an io.Seek* constant is being used instead",
report.Fixes(edit.Fix("swap arguments", edits...)))
}
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
func CheckIneffectiveAppend(pass *analysis.Pass) (interface{}, error) {
isAppend := func(ins ir.Value) bool {
call, ok := ins.(*ir.Call)
if !ok {
return false
}
if call.Call.IsInvoke() {
return false
}
if builtin, ok := call.Call.Value.(*ir.Builtin); !ok || builtin.Name() != "append" {
return false
}
return true
}
// We have to be careful about aliasing.
// Multiple slices may refer to the same backing array,
// making appends observable even when we don't see the result of append be used anywhere.
//
// We will have to restrict ourselves to slices that have been allocated within the function,
// haven't been sliced,
// and haven't been passed anywhere that could retain them (such as function calls or memory stores).
//
// We check whether an append should be flagged in two steps.
//
// In the first step, we look at the data flow graph, starting in reverse from the argument to append, till we reach the root.
// This graph must only consist of the following instructions:
//
// - phi
// - sigma
// - slice
// - const nil
// - MakeSlice
// - Alloc
// - calls to append
//
// If this step succeeds, we look at all referrers of the values found in the first step, recursively.
// These referrers must either be in the set of values found in the first step,
// be DebugRefs,
// or fulfill the same type requirements as step 1, with the exception of appends, which are forbidden.
//
// If both steps succeed then we know that the backing array hasn't been aliased in an observable manner.
//
// We could relax these restrictions by making use of additional information:
// - if we passed the slice to a function that doesn't retain the slice then we can still flag it
// - if a slice has been sliced but is dead afterwards, we can flag appends to the new slice
// OPT(dh): We could cache the results of both validate functions.
// However, we only use these functions on values that we otherwise want to flag, which are very few.
// Not caching values hasn't increased the runtimes for the standard library nor k8s.
var validateArgument func(v ir.Value, seen map[ir.Value]struct{}) bool
validateArgument = func(v ir.Value, seen map[ir.Value]struct{}) bool {
if _, ok := seen[v]; ok {
// break cycle
return true
}
seen[v] = struct{}{}
switch v := v.(type) {
case *ir.Phi:
for _, edge := range v.Edges {
if !validateArgument(edge, seen) {
return false
}
}
return true
case *ir.Sigma:
return validateArgument(v.X, seen)
case *ir.Slice:
return validateArgument(v.X, seen)
case *ir.Const:
return true
case *ir.MakeSlice:
return true
case *ir.Alloc:
return true
case *ir.Call:
if isAppend(v) {
return validateArgument(v.Call.Args[0], seen)
}
return false
default:
return false
}
}
var validateReferrers func(v ir.Value, seen map[ir.Instruction]struct{}) bool
validateReferrers = func(v ir.Value, seen map[ir.Instruction]struct{}) bool {
for _, ref := range *v.Referrers() {
if _, ok := seen[ref]; ok {
continue
}
seen[ref] = struct{}{}
switch ref.(type) {
case *ir.Phi:
case *ir.Sigma:
case *ir.Slice:
case *ir.Const:
case *ir.MakeSlice:
case *ir.Alloc:
case *ir.DebugRef:
default:
return false
}
if ref, ok := ref.(ir.Value); ok {
if !validateReferrers(ref, seen) {
return false
}
}
}
return true
}
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
for _, block := range fn.Blocks {
for _, ins := range block.Instrs {
val, ok := ins.(ir.Value)
if !ok || !isAppend(val) {
continue
}
isUsed := false
visited := map[ir.Instruction]bool{}
var walkRefs func(refs []ir.Instruction)
walkRefs = func(refs []ir.Instruction) {
loop:
for _, ref := range refs {
if visited[ref] {
continue
}
visited[ref] = true
if _, ok := ref.(*ir.DebugRef); ok {
continue
}
switch ref := ref.(type) {
case *ir.Phi:
walkRefs(*ref.Referrers())
case *ir.Sigma:
walkRefs(*ref.Referrers())
case ir.Value:
if !isAppend(ref) {
isUsed = true
} else {
walkRefs(*ref.Referrers())
}
case ir.Instruction:
isUsed = true
break loop
}
}
}
refs := val.Referrers()
if refs == nil {
continue
}
walkRefs(*refs)
if isUsed {
continue
}
seen := map[ir.Value]struct{}{}
if !validateArgument(ins.(*ir.Call).Call.Args[0], seen) {
continue
}
seen2 := map[ir.Instruction]struct{}{}
for k := range seen {
// the only values we allow are also instructions, so this type assertion cannot fail
seen2[k.(ir.Instruction)] = struct{}{}
}
seen2[ins] = struct{}{}
failed := false
for v := range seen {
if !validateReferrers(v, seen2) {
failed = true
break
}
}
if !failed {
report.Report(pass, ins, "this result of append is never used, except maybe in other appends")
}
}
}
}
return nil, nil
}
func CheckConcurrentTesting(pass *analysis.Pass) (interface{}, error) {
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
for _, block := range fn.Blocks {
for _, ins := range block.Instrs {
gostmt, ok := ins.(*ir.Go)
if !ok {
continue
}
var fn *ir.Function
switch val := gostmt.Call.Value.(type) {
case *ir.Function:
fn = val
case *ir.MakeClosure:
fn = val.Fn.(*ir.Function)
default:
continue
}
if fn.Blocks == nil {
continue
}
for _, block := range fn.Blocks {
for _, ins := range block.Instrs {
call, ok := ins.(*ir.Call)
if !ok {
continue
}
if call.Call.IsInvoke() {
continue
}
callee := call.Call.StaticCallee()
if callee == nil {
continue
}
recv := callee.Signature.Recv()
if recv == nil {
continue
}
if !typeutil.IsType(recv.Type(), "*testing.common") {
continue
}
fn, ok := call.Call.StaticCallee().Object().(*types.Func)
if !ok {
continue
}
name := fn.Name()
switch name {
case "FailNow", "Fatal", "Fatalf", "SkipNow", "Skip", "Skipf":
default:
continue
}
// TODO(dh): don't report multiple diagnostics
// for multiple calls to T.Fatal, but do
// collect all of them as related information
report.Report(pass, gostmt, fmt.Sprintf("the goroutine calls T.%s, which must be called in the same goroutine as the test", name),
report.Related(call, fmt.Sprintf("call to T.%s", name)))
}
}
}
}
}
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 CheckCyclicFinalizer(pass *analysis.Pass) (interface{}, error) {
cb := func(caller *ir.Function, site ir.CallInstruction, callee *ir.Function) {
if callee.RelString(nil) != "runtime.SetFinalizer" {
return
}
arg0 := site.Common().Args[knowledge.Arg("runtime.SetFinalizer.obj")]
if iface, ok := arg0.(*ir.MakeInterface); ok {
arg0 = iface.X
}
load, ok := arg0.(*ir.Load)
if !ok {
return
}
v, ok := load.X.(*ir.Alloc)
if !ok {
return
}
arg1 := site.Common().Args[knowledge.Arg("runtime.SetFinalizer.finalizer")]
if iface, ok := arg1.(*ir.MakeInterface); ok {
arg1 = iface.X
}
mc, ok := arg1.(*ir.MakeClosure)
if !ok {
return
}
for _, b := range mc.Bindings {
if b == v {
pos := report.DisplayPosition(pass.Fset, mc.Fn.Pos())
report.Report(pass, site, fmt.Sprintf("the finalizer closes over the object, preventing the finalizer from ever running (at %s)", pos))
}
}
}
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
eachCall(fn, cb)
}
return nil, nil
}
/*
func CheckSliceOutOfBounds(pass *analysis.Pass) (interface{}, error) {
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
for _, block := range fn.Blocks {
for _, ins := range block.Instrs {
ia, ok := ins.(*ir.IndexAddr)
if !ok {
continue
}
if _, ok := ia.X.Type().Underlying().(*types.Slice); !ok {
continue
}
sr, ok1 := c.funcDescs.Get(fn).Ranges[ia.X].(vrp.SliceInterval)
idxr, ok2 := c.funcDescs.Get(fn).Ranges[ia.Index].(vrp.IntInterval)
if !ok1 || !ok2 || !sr.IsKnown() || !idxr.IsKnown() || sr.Length.Empty() || idxr.Empty() {
continue
}
if idxr.Lower.Cmp(sr.Length.Upper) >= 0 {
report.Nodef(pass, ia, "index out of bounds")
}
}
}
}
return nil, nil
}
*/
func CheckDeferLock(pass *analysis.Pass) (interface{}, error) {
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
for _, block := range fn.Blocks {
instrs := irutil.FilterDebug(block.Instrs)
if len(instrs) < 2 {
continue
}
for i, ins := range instrs[:len(instrs)-1] {
call, ok := ins.(*ir.Call)
if !ok {
continue
}
if !irutil.IsCallToAny(call.Common(), "(*sync.Mutex).Lock", "(*sync.RWMutex).RLock") {
continue
}
nins, ok := instrs[i+1].(*ir.Defer)
if !ok {
continue
}
if !irutil.IsCallToAny(&nins.Call, "(*sync.Mutex).Lock", "(*sync.RWMutex).RLock") {
continue
}
if call.Common().Args[0] != nins.Call.Args[0] {
continue
}
name := shortCallName(call.Common())
alt := ""
switch name {
case "Lock":
alt = "Unlock"
case "RLock":
alt = "RUnlock"
}
report.Report(pass, nins, fmt.Sprintf("deferring %s right after having locked already; did you mean to defer %s?", name, alt))
}
}
}
return nil, nil
}
func CheckNaNComparison(pass *analysis.Pass) (interface{}, error) {
isNaN := func(v ir.Value) bool {
call, ok := v.(*ir.Call)
if !ok {
return false
}
return irutil.IsCallTo(call.Common(), "math.NaN")
}
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
for _, block := range fn.Blocks {
for _, ins := range block.Instrs {
ins, ok := ins.(*ir.BinOp)
if !ok {
continue
}
if isNaN(irutil.Flatten(ins.X)) || isNaN(irutil.Flatten(ins.Y)) {
report.Report(pass, ins, "no value is equal to NaN, not even NaN itself")
}
}
}
}
return nil, nil
}
func CheckInfiniteRecursion(pass *analysis.Pass) (interface{}, error) {
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
eachCall(fn, func(caller *ir.Function, site ir.CallInstruction, callee *ir.Function) {
if callee != fn {
return
}
if _, ok := site.(*ir.Go); ok {
// Recursively spawning goroutines doesn't consume
// stack space infinitely, so don't flag it.
return
}
block := site.Block()
canReturn := false
for _, b := range fn.Blocks {
if block.Dominates(b) {
continue
}
if len(b.Instrs) == 0 {
continue
}
if _, ok := b.Control().(*ir.Return); ok {
canReturn = true
break
}
}
if canReturn {
return
}
report.Report(pass, site, "infinite recursive call")
})
}
return nil, nil
}
func objectName(obj types.Object) string {
if obj == nil {
return ""
}
var name string
if obj.Pkg() != nil && obj.Pkg().Scope().Lookup(obj.Name()) == obj {
s := obj.Pkg().Path()
if s != "" {
name += s + "."
}
}
name += obj.Name()
return name
}
func isName(pass *analysis.Pass, expr ast.Expr, name string) bool {
var obj types.Object
switch expr := expr.(type) {
case *ast.Ident:
obj = pass.TypesInfo.ObjectOf(expr)
case *ast.SelectorExpr:
obj = pass.TypesInfo.ObjectOf(expr.Sel)
}
return objectName(obj) == name
}
func CheckLeakyTimeTick(pass *analysis.Pass) (interface{}, error) {
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
if code.IsMainLike(pass) || code.IsInTest(pass, fn) {
continue
}
for _, block := range fn.Blocks {
for _, ins := range block.Instrs {
call, ok := ins.(*ir.Call)
if !ok || !irutil.IsCallTo(call.Common(), "time.Tick") {
continue
}
if !irutil.Terminates(call.Parent()) {
continue
}
report.Report(pass, call, "using time.Tick leaks the underlying ticker, consider using it only in endless functions, tests and the main package, and use time.NewTicker here")
}
}
}
return nil, nil
}
var checkDoubleNegationQ = pattern.MustParse(`(UnaryExpr "!" single@(UnaryExpr "!" x))`)
func CheckDoubleNegation(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
if m, ok := code.Match(pass, checkDoubleNegationQ, node); ok {
report.Report(pass, node, "negating a boolean twice has no effect; is this a typo?", report.Fixes(
edit.Fix("turn into single negation", edit.ReplaceWithNode(pass.Fset, node, m.State["single"].(ast.Node))),
edit.Fix("remove double negation", edit.ReplaceWithNode(pass.Fset, node, m.State["x"].(ast.Node)))))
}
}
code.Preorder(pass, fn, (*ast.UnaryExpr)(nil))
return nil, nil
}
func CheckRepeatedIfElse(pass *analysis.Pass) (interface{}, error) {
seen := map[ast.Node]bool{}
var collectConds func(ifstmt *ast.IfStmt, conds []ast.Expr) ([]ast.Expr, bool)
collectConds = func(ifstmt *ast.IfStmt, conds []ast.Expr) ([]ast.Expr, bool) {
seen[ifstmt] = true
// Bail if any if-statement has an Init statement or side effects in its condition
if ifstmt.Init != nil {
return nil, false
}
if code.MayHaveSideEffects(pass, ifstmt.Cond, nil) {
return nil, false
}
conds = append(conds, ifstmt.Cond)
if elsestmt, ok := ifstmt.Else.(*ast.IfStmt); ok {
return collectConds(elsestmt, conds)
}
return conds, true
}
fn := func(node ast.Node) {
ifstmt := node.(*ast.IfStmt)
if seen[ifstmt] {
// this if-statement is part of an if/else-if chain that we've already processed
return
}
if ifstmt.Else == nil {
// there can be at most one condition
return
}
conds, ok := collectConds(ifstmt, nil)
if !ok {
return
}
if len(conds) < 2 {
return
}
counts := map[string]int{}
for _, cond := range conds {
s := report.Render(pass, cond)
counts[s]++
if counts[s] == 2 {
report.Report(pass, cond, "this condition occurs multiple times in this if/else if chain")
}
}
}
code.Preorder(pass, fn, (*ast.IfStmt)(nil))
return nil, nil
}
func CheckSillyBitwiseOps(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
binop := node.(*ast.BinaryExpr)
b, ok := pass.TypesInfo.TypeOf(binop).Underlying().(*types.Basic)
if !ok {
return
}
if (b.Info() & types.IsInteger) == 0 {
return
}
switch binop.Op {
case token.AND, token.OR, token.XOR:
default:
// we do not flag shifts because too often, x<<0 is part
// of a pattern, x<<0, x<<8, x<<16, ...
return
}
switch y := binop.Y.(type) {
case *ast.Ident:
obj, ok := pass.TypesInfo.ObjectOf(y).(*types.Const)
if !ok {
return
}
if obj.Pkg() != pass.Pkg {
// identifier was dot-imported
return
}
if v, _ := constant.Int64Val(obj.Val()); v != 0 {
return
}
path, _ := astutil.PathEnclosingInterval(code.File(pass, obj), obj.Pos(), obj.Pos())
if len(path) < 2 {
return
}
spec, ok := path[1].(*ast.ValueSpec)
if !ok {
return
}
if len(spec.Names) != 1 || len(spec.Values) != 1 {
// TODO(dh): we could support this
return
}
ident, ok := spec.Values[0].(*ast.Ident)
if !ok {
return
}
if !isIota(pass.TypesInfo.ObjectOf(ident)) {
return
}
switch binop.Op {
case token.AND:
report.Report(pass, node,
fmt.Sprintf("%s always equals 0; %s is defined as iota and has value 0, maybe %s is meant to be 1 << iota?", report.Render(pass, binop), report.Render(pass, binop.Y), report.Render(pass, binop.Y)))
case token.OR, token.XOR:
report.Report(pass, node,
fmt.Sprintf("%s always equals %s; %s is defined as iota and has value 0, maybe %s is meant to be 1 << iota?", report.Render(pass, binop), report.Render(pass, binop.X), report.Render(pass, binop.Y), report.Render(pass, binop.Y)))
}
case *ast.BasicLit:
if !astutil.IsIntLiteral(binop.Y, "0") {
return
}
switch binop.Op {
case token.AND:
report.Report(pass, node, fmt.Sprintf("%s always equals 0", report.Render(pass, binop)))
case token.OR, token.XOR:
report.Report(pass, node, fmt.Sprintf("%s always equals %s", report.Render(pass, binop), report.Render(pass, binop.X)))
}
default:
return
}
}
code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
return nil, nil
}
func isIota(obj types.Object) bool {
if obj.Name() != "iota" {
return false
}
c, ok := obj.(*types.Const)
if !ok {
return false
}
return c.Pkg() == nil
}
func CheckNonOctalFileMode(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
call := node.(*ast.CallExpr)
for _, arg := range call.Args {
lit, ok := arg.(*ast.BasicLit)
if !ok {
continue
}
if !typeutil.IsType(pass.TypesInfo.TypeOf(lit), "os.FileMode") &&
!typeutil.IsType(pass.TypesInfo.TypeOf(lit), "io/fs.FileMode") {
continue
}
if len(lit.Value) == 3 &&
lit.Value[0] != '0' &&
lit.Value[0] >= '0' && lit.Value[0] <= '7' &&
lit.Value[1] >= '0' && lit.Value[1] <= '7' &&
lit.Value[2] >= '0' && lit.Value[2] <= '7' {
v, err := strconv.ParseInt(lit.Value, 10, 64)
if err != nil {
continue
}
report.Report(pass, arg, fmt.Sprintf("file mode '%s' evaluates to %#o; did you mean '0%s'?", lit.Value, v, lit.Value),
report.Fixes(edit.Fix("fix octal literal", edit.ReplaceWithString(pass.Fset, arg, "0"+lit.Value))))
}
}
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
func CheckPureFunctions(pass *analysis.Pass) (interface{}, error) {
pure := pass.ResultOf[facts.Purity].(facts.PurityResult)
fnLoop:
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
if code.IsInTest(pass, fn) {
params := fn.Signature.Params()
for i := 0; i < params.Len(); i++ {
param := params.At(i)
if typeutil.IsType(param.Type(), "*testing.B") {
// Ignore discarded pure functions in code related
// to benchmarks. Instead of matching BenchmarkFoo
// functions, we match any function accepting a
// *testing.B. Benchmarks sometimes call generic
// functions for doing the actual work, and
// checking for the parameter is a lot easier and
// faster than analyzing call trees.
continue fnLoop
}
}
}
for _, b := range fn.Blocks {
for _, ins := range b.Instrs {
ins, ok := ins.(*ir.Call)
if !ok {
continue
}
refs := ins.Referrers()
if refs == nil || len(irutil.FilterDebug(*refs)) > 0 {
continue
}
callee := ins.Common().StaticCallee()
if callee == nil {
continue
}
if callee.Object() == nil {
// TODO(dh): support anonymous functions
continue
}
if _, ok := pure[callee.Object().(*types.Func)]; ok {
if pass.Pkg.Path() == "fmt_test" && callee.Object().(*types.Func).FullName() == "fmt.Sprintf" {
// special case for benchmarks in the fmt package
continue
}
report.Report(pass, ins, fmt.Sprintf("%s is a pure function but its return value is ignored", callee.Name()))
}
}
}
}
return nil, nil
}
func CheckDeprecated(pass *analysis.Pass) (interface{}, error) {
deprs := pass.ResultOf[facts.Deprecated].(facts.DeprecatedResult)
// Selectors can appear outside of function literals, e.g. when
// declaring package level variables.
var tfn types.Object
stack := 0
fn := func(node ast.Node, push bool) bool {
if !push {
stack--
return false
}
stack++
if stack == 1 {
tfn = nil
}
if fn, ok := node.(*ast.FuncDecl); ok {
tfn = pass.TypesInfo.ObjectOf(fn.Name)
}
sel, ok := node.(*ast.SelectorExpr)
if !ok {
return true
}
obj := pass.TypesInfo.ObjectOf(sel.Sel)
if obj.Pkg() == nil {
return true
}
if pass.Pkg == obj.Pkg() || obj.Pkg().Path()+"_test" == pass.Pkg.Path() {
// Don't flag stuff in our own package
return true
}
if depr, ok := deprs.Objects[obj]; ok {
// Note: gopls doesn't correctly run analyzers on
// dependencies, so we'll never be able to find deprecated
// objects in imported code. We've experimented with
// lifting the stdlib handling out of the general check,
// to at least work for deprecated objects in the stdlib,
// but we gave up on that, because we wouldn't have access
// to the deprecation message.
std, ok := knowledge.StdlibDeprecations[code.SelectorName(pass, sel)]
if ok {
switch std.AlternativeAvailableSince {
case knowledge.DeprecatedNeverUse:
// This should never be used, regardless of the
// targeted Go version. Examples include insecure
// cryptography or inherently broken APIs.
//
// We always want to flag these.
case knowledge.DeprecatedUseNoLonger:
// This should no longer be used. Using it with
// older Go versions might still make sense.
if !code.IsGoVersion(pass, std.DeprecatedSince) {
return true
}
default:
if std.AlternativeAvailableSince < 0 {
panic(fmt.Sprintf("unhandled case %d", std.AlternativeAvailableSince))
}
// Look for the first available alternative, not the first
// version something was deprecated in. If a function was
// deprecated in Go 1.6, an alternative has been available
// already in 1.0, and we're targeting 1.2, it still
// makes sense to use the alternative from 1.0, to be
// future-proof.
if !code.IsGoVersion(pass, std.AlternativeAvailableSince) {
return true
}
}
}
if tfn != nil {
if _, ok := deprs.Objects[tfn]; ok {
// functions that are deprecated may use deprecated
// symbols
return true
}
}
if ok {
if std.AlternativeAvailableSince == knowledge.DeprecatedNeverUse {
report.Report(pass, sel, fmt.Sprintf("%s has been deprecated since Go 1.%d because it shouldn't be used: %s", report.Render(pass, sel), std.DeprecatedSince, depr.Msg))
} else if std.AlternativeAvailableSince == std.DeprecatedSince || std.AlternativeAvailableSince == knowledge.DeprecatedUseNoLonger {
report.Report(pass, sel, fmt.Sprintf("%s has been deprecated since Go 1.%d: %s", report.Render(pass, sel), std.DeprecatedSince, depr.Msg))
} else {
report.Report(pass, sel, fmt.Sprintf("%s has been deprecated since Go 1.%d and an alternative has been available since Go 1.%d: %s", report.Render(pass, sel), std.DeprecatedSince, std.AlternativeAvailableSince, depr.Msg))
}
} else {
report.Report(pass, sel, fmt.Sprintf("%s is deprecated: %s", report.Render(pass, sel), depr.Msg))
}
return true
}
return true
}
fn2 := func(node ast.Node) {
spec := node.(*ast.ImportSpec)
var imp *types.Package
if spec.Name != nil {
imp = pass.TypesInfo.ObjectOf(spec.Name).(*types.PkgName).Imported()
} else {
imp = pass.TypesInfo.Implicits[spec].(*types.PkgName).Imported()
}
p := spec.Path.Value
path := p[1 : len(p)-1]
if depr, ok := deprs.Packages[imp]; ok {
if path == "github.com/golang/protobuf/proto" {
gen, ok := code.Generator(pass, spec.Path.Pos())
if ok && gen == facts.ProtocGenGo {
return
}
}
report.Report(pass, spec, fmt.Sprintf("package %s is deprecated: %s", path, depr.Msg))
}
}
pass.ResultOf[inspect.Analyzer].(*inspector.Inspector).Nodes(nil, fn)
code.Preorder(pass, fn2, (*ast.ImportSpec)(nil))
return nil, nil
}
func callChecker(rules map[string]CallCheck) 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]CallCheck) (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 shortCallName(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 fn.Name()
case *ir.Builtin:
return v.Name()
}
return ""
}
func CheckWriterBufferModified(pass *analysis.Pass) (interface{}, error) {
// TODO(dh): this might be a good candidate for taint analysis.
// Taint the argument as MUST_NOT_MODIFY, then propagate that
// through functions like bytes.Split
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
sig := fn.Signature
if fn.Name() != "Write" || sig.Recv() == nil || sig.Params().Len() != 1 || sig.Results().Len() != 2 {
continue
}
tArg, ok := sig.Params().At(0).Type().(*types.Slice)
if !ok {
continue
}
if basic, ok := tArg.Elem().(*types.Basic); !ok || basic.Kind() != types.Byte {
continue
}
if basic, ok := sig.Results().At(0).Type().(*types.Basic); !ok || basic.Kind() != types.Int {
continue
}
if named, ok := sig.Results().At(1).Type().(*types.Named); !ok || !typeutil.IsType(named, "error") {
continue
}
for _, block := range fn.Blocks {
for _, ins := range block.Instrs {
switch ins := ins.(type) {
case *ir.Store:
addr, ok := ins.Addr.(*ir.IndexAddr)
if !ok {
continue
}
if addr.X != fn.Params[1] {
continue
}
report.Report(pass, ins, "io.Writer.Write must not modify the provided buffer, not even temporarily")
case *ir.Call:
if !irutil.IsCallTo(ins.Common(), "append") {
continue
}
if ins.Common().Args[0] != fn.Params[1] {
continue
}
report.Report(pass, ins, "io.Writer.Write must not modify the provided buffer, not even temporarily")
}
}
}
}
return nil, nil
}
func loopedRegexp(name string) CallCheck {
return func(call *Call) {
if extractConst(call.Args[0].Value.Value) == nil {
return
}
if !isInLoop(call.Instr.Block()) {
return
}
call.Invalid(fmt.Sprintf("calling %s in a loop has poor performance, consider using regexp.Compile", name))
}
}
func CheckEmptyBranch(pass *analysis.Pass) (interface{}, error) {
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
if fn.Source() == nil {
continue
}
if irutil.IsExample(fn) {
continue
}
cb := func(node ast.Node) bool {
ifstmt, ok := node.(*ast.IfStmt)
if !ok {
return true
}
if ifstmt.Else != nil {
b, ok := ifstmt.Else.(*ast.BlockStmt)
if !ok || len(b.List) != 0 {
return true
}
report.Report(pass, ifstmt.Else, "empty branch", report.FilterGenerated(), report.ShortRange())
}
if len(ifstmt.Body.List) != 0 {
return true
}
report.Report(pass, ifstmt, "empty branch", report.FilterGenerated(), report.ShortRange())
return true
}
if source := fn.Source(); source != nil {
ast.Inspect(source, cb)
}
}
return nil, nil
}
func CheckMapBytesKey(pass *analysis.Pass) (interface{}, error) {
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
for _, b := range fn.Blocks {
insLoop:
for _, ins := range b.Instrs {
// find []byte -> string conversions
conv, ok := ins.(*ir.Convert)
if !ok || conv.Type() != types.Universe.Lookup("string").Type() {
continue
}
if s, ok := conv.X.Type().(*types.Slice); !ok || s.Elem() != types.Universe.Lookup("byte").Type() {
continue
}
refs := conv.Referrers()
// need at least two (DebugRef) references: the
// conversion and the *ast.Ident
if refs == nil || len(*refs) < 2 {
continue
}
ident := false
// skip first reference, that's the conversion itself
for _, ref := range (*refs)[1:] {
switch ref := ref.(type) {
case *ir.DebugRef:
if _, ok := ref.Expr.(*ast.Ident); !ok {
// the string seems to be used somewhere
// unexpected; the default branch should
// catch this already, but be safe
continue insLoop
} else {
ident = true
}
case *ir.MapLookup:
default:
// the string is used somewhere else than a
// map lookup
continue insLoop
}
}
// the result of the conversion wasn't assigned to an
// identifier
if !ident {
continue
}
report.Report(pass, conv, "m[string(key)] would be more efficient than k := string(key); m[k]")
}
}
}
return nil, nil
}
func CheckRangeStringRunes(pass *analysis.Pass) (interface{}, error) {
return sharedcheck.CheckRangeStringRunes(pass)
}
func CheckSelfAssignment(pass *analysis.Pass) (interface{}, error) {
pure := pass.ResultOf[facts.Purity].(facts.PurityResult)
fn := func(node ast.Node) {
assign := node.(*ast.AssignStmt)
if assign.Tok != token.ASSIGN || len(assign.Lhs) != len(assign.Rhs) {
return
}
for i, lhs := range assign.Lhs {
rhs := assign.Rhs[i]
if reflect.TypeOf(lhs) != reflect.TypeOf(rhs) {
continue
}
if code.MayHaveSideEffects(pass, lhs, pure) || code.MayHaveSideEffects(pass, rhs, pure) {
continue
}
rlh := report.Render(pass, lhs)
rrh := report.Render(pass, rhs)
if rlh == rrh {
report.Report(pass, assign, fmt.Sprintf("self-assignment of %s to %s", rrh, rlh), report.FilterGenerated())
}
}
}
code.Preorder(pass, fn, (*ast.AssignStmt)(nil))
return nil, nil
}
func buildTagsIdentical(s1, s2 []string) bool {
if len(s1) != len(s2) {
return false
}
s1s := make([]string, len(s1))
copy(s1s, s1)
sort.Strings(s1s)
s2s := make([]string, len(s2))
copy(s2s, s2)
sort.Strings(s2s)
for i, s := range s1s {
if s != s2s[i] {
return false
}
}
return true
}
func CheckDuplicateBuildConstraints(pass *analysis.Pass) (interface{}, error) {
for _, f := range pass.Files {
constraints := buildTags(f)
for i, constraint1 := range constraints {
for j, constraint2 := range constraints {
if i >= j {
continue
}
if buildTagsIdentical(constraint1, constraint2) {
msg := fmt.Sprintf("identical build constraints %q and %q",
strings.Join(constraint1, " "),
strings.Join(constraint2, " "))
report.Report(pass, f, msg, report.FilterGenerated(), report.ShortRange())
}
}
}
}
return nil, nil
}
func CheckSillyRegexp(pass *analysis.Pass) (interface{}, error) {
// We could use the rule checking engine for this, but the
// arguments aren't really invalid.
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
for _, b := range fn.Blocks {
for _, ins := range b.Instrs {
call, ok := ins.(*ir.Call)
if !ok {
continue
}
if !irutil.IsCallToAny(call.Common(), "regexp.MustCompile", "regexp.Compile", "regexp.Match", "regexp.MatchReader", "regexp.MatchString") {
continue
}
c, ok := call.Common().Args[0].(*ir.Const)
if !ok {
continue
}
s := constant.StringVal(c.Value)
re, err := syntax.Parse(s, 0)
if err != nil {
continue
}
if re.Op != syntax.OpLiteral && re.Op != syntax.OpEmptyMatch {
continue
}
report.Report(pass, call, "regular expression does not contain any meta characters")
}
}
}
return nil, nil
}
func CheckMissingEnumTypesInDeclaration(pass *analysis.Pass) (interface{}, error) {
convertibleTo := func(V, T types.Type) bool {
if types.ConvertibleTo(V, T) {
return true
}
// Go <1.16 returns false for untyped string to string conversion
if V, ok := V.(*types.Basic); ok && V.Kind() == types.UntypedString {
if T, ok := T.Underlying().(*types.Basic); ok && T.Kind() == types.String {
return true
}
}
return false
}
fn := func(node ast.Node) {
decl := node.(*ast.GenDecl)
if !decl.Lparen.IsValid() {
return
}
if decl.Tok != token.CONST {
return
}
groups := astutil.GroupSpecs(pass.Fset, decl.Specs)
groupLoop:
for _, group := range groups {
if len(group) < 2 {
continue
}
if group[0].(*ast.ValueSpec).Type == nil {
// first constant doesn't have a type
continue groupLoop
}
firstType := pass.TypesInfo.TypeOf(group[0].(*ast.ValueSpec).Values[0])
for i, spec := range group {
spec := spec.(*ast.ValueSpec)
if i > 0 && spec.Type != nil {
continue groupLoop
}
if len(spec.Names) != 1 || len(spec.Values) != 1 {
continue groupLoop
}
if !convertibleTo(pass.TypesInfo.TypeOf(spec.Values[0]), firstType) {
continue groupLoop
}
switch v := spec.Values[0].(type) {
case *ast.BasicLit:
case *ast.UnaryExpr:
if _, ok := v.X.(*ast.BasicLit); !ok {
continue groupLoop
}
default:
// if it's not a literal it might be typed, such as
// time.Microsecond = 1000 * Nanosecond
continue groupLoop
}
}
var edits []analysis.TextEdit
typ := group[0].(*ast.ValueSpec).Type
for _, spec := range group[1:] {
nspec := *spec.(*ast.ValueSpec)
nspec.Type = typ
// The position of `spec` node excludes comments (if any).
// However, on generating the source back from the node, the comments are included. Setting `Comment` to nil ensures deduplication of comments.
nspec.Comment = nil
edits = append(edits, edit.ReplaceWithNode(pass.Fset, spec, &nspec))
}
report.Report(pass, group[0], "only the first constant in this group has an explicit type", report.Fixes(edit.Fix("add type to all constants in group", edits...)))
}
}
code.Preorder(pass, fn, (*ast.GenDecl)(nil))
return nil, nil
}
func CheckTimerResetReturnValue(pass *analysis.Pass) (interface{}, error) {
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
for _, block := range fn.Blocks {
for _, ins := range block.Instrs {
call, ok := ins.(*ir.Call)
if !ok {
continue
}
if !irutil.IsCallTo(call.Common(), "(*time.Timer).Reset") {
continue
}
refs := call.Referrers()
if refs == nil {
continue
}
for _, ref := range irutil.FilterDebug(*refs) {
ifstmt, ok := ref.(*ir.If)
if !ok {
continue
}
found := false
for _, succ := range ifstmt.Block().Succs {
if len(succ.Preds) != 1 {
// Merge point, not a branch in the
// syntactical sense.
// FIXME(dh): this is broken for if
// statements a la "if x || y"
continue
}
irutil.Walk(succ, func(b *ir.BasicBlock) bool {
if !succ.Dominates(b) {
// We've reached the end of the branch
return false
}
for _, ins := range b.Instrs {
// TODO(dh): we should check that
// we're receiving from the channel of
// a time.Timer to further reduce
// false positives. Not a key
// priority, considering the rarity of
// Reset and the tiny likeliness of a
// false positive
if ins, ok := ins.(*ir.Recv); ok && typeutil.IsType(ins.Chan.Type(), "<-chan time.Time") {
found = true
return false
}
}
return true
})
}
if found {
report.Report(pass, call, "it is not possible to use Reset's return value correctly, as there is a race condition between draining the channel and the new timer expiring")
}
}
}
}
}
return nil, nil
}
var (
checkToLowerToUpperComparisonQ = pattern.MustParse(`
(BinaryExpr
(CallExpr fun@(Function (Or "strings.ToLower" "strings.ToUpper")) [a])
tok@(Or "==" "!=")
(CallExpr fun [b]))`)
checkToLowerToUpperComparisonR = pattern.MustParse(`(CallExpr (SelectorExpr (Ident "strings") (Ident "EqualFold")) [a b])`)
)
func CheckToLowerToUpperComparison(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
m, ok := code.Match(pass, checkToLowerToUpperComparisonQ, node)
if !ok {
return
}
rn := pattern.NodeToAST(checkToLowerToUpperComparisonR.Root, m.State).(ast.Expr)
if m.State["tok"].(token.Token) == token.NEQ {
rn = &ast.UnaryExpr{
Op: token.NOT,
X: rn,
}
}
report.Report(pass, node, "should use strings.EqualFold instead", report.Fixes(edit.Fix("replace with strings.EqualFold", edit.ReplaceWithNode(pass.Fset, node, rn))))
}
code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
return nil, nil
}
func CheckUnreachableTypeCases(pass *analysis.Pass) (interface{}, error) {
// Check if T subsumes V in a type switch. T subsumes V if T is an interface and T's method set is a subset of V's method set.
subsumes := func(T, V types.Type) bool {
tIface, ok := T.Underlying().(*types.Interface)
if !ok {
return false
}
return types.Implements(V, tIface)
}
subsumesAny := func(Ts, Vs []types.Type) (types.Type, types.Type, bool) {
for _, T := range Ts {
for _, V := range Vs {
if subsumes(T, V) {
return T, V, true
}
}
}
return nil, nil, false
}
fn := func(node ast.Node) {
tsStmt := node.(*ast.TypeSwitchStmt)
type ccAndTypes struct {
cc *ast.CaseClause
types []types.Type
}
// All asserted types in the order of case clauses.
ccs := make([]ccAndTypes, 0, len(tsStmt.Body.List))
for _, stmt := range tsStmt.Body.List {
cc, _ := stmt.(*ast.CaseClause)
// Exclude the 'default' case.
if len(cc.List) == 0 {
continue
}
Ts := make([]types.Type, 0, len(cc.List))
for _, expr := range cc.List {
// Exclude the 'nil' value from any 'case' statement (it is always reachable).
if typ := pass.TypesInfo.TypeOf(expr); typ != types.Typ[types.UntypedNil] {
Ts = append(Ts, typ)
}
}
ccs = append(ccs, ccAndTypes{cc: cc, types: Ts})
}
if len(ccs) <= 1 {
// Zero or one case clauses, nothing to check.
return
}
// Check if case clauses following cc have types that are subsumed by cc.
for i, cc := range ccs[:len(ccs)-1] {
for _, next := range ccs[i+1:] {
if T, V, yes := subsumesAny(cc.types, next.types); yes {
report.Report(pass, next.cc, fmt.Sprintf("unreachable case clause: %s will always match before %s", T.String(), V.String()),
report.ShortRange())
}
}
}
}
code.Preorder(pass, fn, (*ast.TypeSwitchStmt)(nil))
return nil, nil
}
var checkSingleArgAppendQ = pattern.MustParse(`(CallExpr (Builtin "append") [_])`)
func CheckSingleArgAppend(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
_, ok := code.Match(pass, checkSingleArgAppendQ, node)
if !ok {
return
}
report.Report(pass, node, "x = append(y) is equivalent to x = y", report.FilterGenerated())
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
func CheckStructTags(pass *analysis.Pass) (interface{}, error) {
importsGoFlags := false
// we use the AST instead of (*types.Package).Imports to work
// around vendored packages in GOPATH mode. A vendored package's
// path will include the vendoring subtree as a prefix.
for _, f := range pass.Files {
for _, imp := range f.Imports {
v := imp.Path.Value
if v[1:len(v)-1] == "github.com/jessevdk/go-flags" {
importsGoFlags = true
break
}
}
}
fn := func(node ast.Node) {
structNode := node.(*ast.StructType)
T := pass.TypesInfo.Types[structNode].Type.(*types.Struct)
rt := fakereflect.TypeAndCanAddr{
Type: T,
}
for i, field := range structNode.Fields.List {
if field.Tag == nil {
continue
}
tags, err := parseStructTag(field.Tag.Value[1 : len(field.Tag.Value)-1])
if err != nil {
report.Report(pass, field.Tag, fmt.Sprintf("unparseable struct tag: %s", err))
continue
}
for k, v := range tags {
if len(v) > 1 {
isGoFlagsTag := importsGoFlags &&
(k == "choice" || k == "optional-value" || k == "default")
if !isGoFlagsTag {
report.Report(pass, field.Tag, fmt.Sprintf("duplicate struct tag %q", k))
}
}
switch k {
case "json":
checkJSONTag(pass, field, v[0])
case "xml":
if _, err := fakexml.StructFieldInfo(rt.Field(i)); err != nil {
report.Report(pass, field.Tag, fmt.Sprintf("invalid XML tag: %s", err))
}
checkXMLTag(pass, field, v[0])
}
}
}
}
code.Preorder(pass, fn, (*ast.StructType)(nil))
return nil, nil
}
func checkJSONTag(pass *analysis.Pass, field *ast.Field, tag string) {
if pass.Pkg.Path() == "encoding/json" || pass.Pkg.Path() == "encoding/json_test" {
// don't flag malformed JSON tags in the encoding/json
// package; it knows what it is doing, and it is testing
// itself.
return
}
//lint:ignore SA9003 TODO(dh): should we flag empty tags?
if len(tag) == 0 {
}
fields := strings.Split(tag, ",")
for _, r := range fields[0] {
if !unicode.IsLetter(r) && !unicode.IsDigit(r) && !strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", r) {
report.Report(pass, field.Tag, fmt.Sprintf("invalid JSON field name %q", fields[0]))
}
}
var co, cs, ci int
for _, s := range fields[1:] {
switch s {
case "omitempty":
co++
case "":
// allow stuff like "-,"
case "string":
cs++
// only for string, floating point, integer and bool
T := typeutil.Dereference(pass.TypesInfo.TypeOf(field.Type).Underlying()).Underlying()
basic, ok := T.(*types.Basic)
if !ok || (basic.Info()&(types.IsBoolean|types.IsInteger|types.IsFloat|types.IsString)) == 0 {
report.Report(pass, field.Tag, "the JSON string option only applies to fields of type string, floating point, integer or bool, or pointers to those")
}
case "inline":
ci++
default:
report.Report(pass, field.Tag, fmt.Sprintf("unknown JSON option %q", s))
}
}
if co > 1 {
report.Report(pass, field.Tag, `duplicate JSON option "omitempty"`)
}
if cs > 1 {
report.Report(pass, field.Tag, `duplicate JSON option "string"`)
}
if ci > 1 {
report.Report(pass, field.Tag, `duplicate JSON option "inline"`)
}
}
func checkXMLTag(pass *analysis.Pass, field *ast.Field, tag string) {
//lint:ignore SA9003 TODO(dh): should we flag empty tags?
if len(tag) == 0 {
}
fields := strings.Split(tag, ",")
counts := map[string]int{}
for _, s := range fields[1:] {
switch s {
case "attr", "chardata", "cdata", "innerxml", "comment":
counts[s]++
case "omitempty", "any":
counts[s]++
case "":
default:
report.Report(pass, field.Tag, fmt.Sprintf("invalid XML tag: unknown option %q", s))
}
}
for k, v := range counts {
if v > 1 {
report.Report(pass, field.Tag, fmt.Sprintf("invalid XML tag: duplicate option %q", k))
}
}
}
func CheckImpossibleTypeAssertion(pass *analysis.Pass) (interface{}, error) {
type entry struct {
l, r *types.Func
}
msc := &pass.ResultOf[buildir.Analyzer].(*buildir.IR).Pkg.Prog.MethodSets
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
for _, b := range fn.Blocks {
for _, instr := range b.Instrs {
assert, ok := instr.(*ir.TypeAssert)
if !ok {
continue
}
var wrong []entry
left := assert.X.Type()
right := assert.AssertedType
righti, ok := right.Underlying().(*types.Interface)
if !ok {
// We only care about interface->interface
// assertions. The Go compiler already catches
// impossible interface->concrete assertions.
continue
}
ms := msc.MethodSet(left)
for i := 0; i < righti.NumMethods(); i++ {
mr := righti.Method(i)
sel := ms.Lookup(mr.Pkg(), mr.Name())
if sel == nil {
continue
}
ml := sel.Obj().(*types.Func)
if types.AssignableTo(ml.Type(), mr.Type()) {
continue
}
wrong = append(wrong, entry{ml, mr})
}
if len(wrong) != 0 {
s := fmt.Sprintf("impossible type assertion; %s and %s contradict each other:",
types.TypeString(left, types.RelativeTo(pass.Pkg)),
types.TypeString(right, types.RelativeTo(pass.Pkg)))
for _, e := range wrong {
s += fmt.Sprintf("\n\twrong type for %s method", e.l.Name())
s += fmt.Sprintf("\n\t\thave %s", e.l.Type())
s += fmt.Sprintf("\n\t\twant %s", e.r.Type())
}
report.Report(pass, assert, s)
}
}
}
}
return nil, nil
}
func checkWithValueKey(call *Call) {
arg := call.Args[1]
T := arg.Value.Value.Type()
if T, ok := T.(*types.Basic); ok {
arg.Invalid(
fmt.Sprintf("should not use built-in type %s as key for value; define your own type to avoid collisions", T))
}
if !types.Comparable(T) {
arg.Invalid(fmt.Sprintf("keys used with context.WithValue must be comparable, but type %s is not comparable", T))
}
}
func CheckMaybeNil(pass *analysis.Pass) (interface{}, error) {
// This is an extremely trivial check that doesn't try to reason
// about control flow. That is, phis and sigmas do not propagate
// any information. As such, we can flag this:
//
// _ = *x
// if x == nil { return }
//
// but we cannot flag this:
//
// if x == nil { println(x) }
// _ = *x
//
// nor many other variations of conditional uses of or assignments to x.
//
// However, even this trivial implementation finds plenty of
// real-world bugs, such as dereference before nil pointer check,
// or using t.Error instead of t.Fatal when encountering nil
// pointers.
//
// On the flip side, our naive implementation avoids false positives in branches, such as
//
// if x != nil { _ = *x }
//
// due to the same lack of propagating information through sigma
// nodes. x inside the branch will be independent of the x in the
// nil pointer check.
//
//
// We could implement a more powerful check, but then we'd be
// getting false positives instead of false negatives because
// we're incapable of deducing relationships between variables.
// For example, a function might return a pointer and an error,
// and the error being nil guarantees that the pointer is not nil.
// Depending on the surrounding code, the pointer may still end up
// being checked against nil in one place, and guarded by a check
// on the error in another, which would lead to us marking some
// loads as unsafe.
//
// Unfortunately, simply hard-coding the relationship between
// return values wouldn't eliminate all false positives, either.
// Many other more subtle relationships exist. An abridged example
// from real code:
//
// if a == nil && b == nil { return }
// c := fn(a)
// if c != "" { _ = *a }
//
// where `fn` is guaranteed to return a non-empty string if a
// isn't nil.
//
// We choose to err on the side of false negatives.
isNilConst := func(v ir.Value) bool {
if typeutil.IsPointerLike(v.Type()) {
if k, ok := v.(*ir.Const); ok {
return k.IsNil()
}
}
return false
}
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
maybeNil := map[ir.Value]ir.Instruction{}
for _, b := range fn.Blocks {
for _, instr := range b.Instrs {
// Originally we looked at all ir.BinOp, but that would lead to calls like 'assert(x != nil)' causing false positives.
// Restrict ourselves to actual if statements, as these are more likely to affect control flow in a way we can observe.
if instr, ok := instr.(*ir.If); ok {
if cond, ok := instr.Cond.(*ir.BinOp); ok {
var ptr ir.Value
if isNilConst(cond.X) {
ptr = cond.Y
} else if isNilConst(cond.Y) {
ptr = cond.X
}
maybeNil[ptr] = cond
}
}
}
}
for _, b := range fn.Blocks {
for _, instr := range b.Instrs {
var ptr ir.Value
switch instr := instr.(type) {
case *ir.Load:
ptr = instr.X
case *ir.Store:
ptr = instr.Addr
case *ir.IndexAddr:
ptr = instr.X
if _, ok := ptr.Type().Underlying().(*types.Slice); ok {
// indexing a nil slice does not cause a nil pointer panic
//
// Note: This also works around the bad lowering of range loops over slices
// (https://github.com/dominikh/go-tools/issues/1053)
continue
}
case *ir.FieldAddr:
ptr = instr.X
}
if ptr != nil {
switch ptr.(type) {
case *ir.Alloc, *ir.FieldAddr, *ir.IndexAddr:
// these cannot be nil
continue
}
if r, ok := maybeNil[ptr]; ok {
report.Report(pass, instr, "possible nil pointer dereference",
report.Related(r, "this check suggests that the pointer can be nil"))
}
}
}
}
}
return nil, nil
}
var checkAddressIsNilQ = pattern.MustParse(
`(BinaryExpr
(UnaryExpr "&" _)
(Or "==" "!=")
(Builtin "nil"))`)
func CheckAddressIsNil(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
_, ok := code.Match(pass, checkAddressIsNilQ, node)
if !ok {
return
}
report.Report(pass, node, "the address of a variable cannot be nil")
}
code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
return nil, nil
}
var (
checkFixedLengthTypeShiftQ = pattern.MustParse(`
(Or
(AssignStmt _ (Or ">>=" "<<=") _)
(BinaryExpr _ (Or ">>" "<<") _))
`)
)
func CheckStaticBitShift(pass *analysis.Pass) (interface{}, error) {
isDubiousShift := func(x, y ast.Expr) (int64, int64, bool) {
typ, ok := pass.TypesInfo.TypeOf(x).Underlying().(*types.Basic)
if !ok {
return 0, 0, false
}
switch typ.Kind() {
case types.Int8, types.Int16, types.Int32, types.Int64,
types.Uint8, types.Uint16, types.Uint32, types.Uint64:
// We're only interested in fixedβsize types.
default:
return 0, 0, false
}
const bitsInByte = 8
typeBits := pass.TypesSizes.Sizeof(typ) * bitsInByte
shiftLength, ok := code.ExprToInt(pass, y)
if !ok {
return 0, 0, false
}
return typeBits, shiftLength, shiftLength >= typeBits
}
fn := func(node ast.Node) {
if _, ok := code.Match(pass, checkFixedLengthTypeShiftQ, node); !ok {
return
}
switch e := node.(type) {
case *ast.AssignStmt:
if size, shift, yes := isDubiousShift(e.Lhs[0], e.Rhs[0]); yes {
report.Report(pass, e, fmt.Sprintf("shifting %d-bit value by %d bits will always clear it", size, shift))
}
case *ast.BinaryExpr:
if size, shift, yes := isDubiousShift(e.X, e.Y); yes {
report.Report(pass, e, fmt.Sprintf("shifting %d-bit value by %d bits will always clear it", size, shift))
}
}
}
code.Preorder(pass, fn, (*ast.AssignStmt)(nil), (*ast.BinaryExpr)(nil))
return nil, nil
}
func findSliceLenChecks(pass *analysis.Pass) {
// mark all function parameters that have to be of even length
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
for _, b := range fn.Blocks {
// all paths go through this block
if !b.Dominates(fn.Exit) {
continue
}
// if foo % 2 != 0
ifi, ok := b.Control().(*ir.If)
if !ok {
continue
}
cmp, ok := ifi.Cond.(*ir.BinOp)
if !ok {
continue
}
var needle uint64
switch cmp.Op {
case token.NEQ:
// look for != 0
needle = 0
case token.EQL:
// look for == 1
needle = 1
default:
continue
}
rem, ok1 := cmp.X.(*ir.BinOp)
k, ok2 := cmp.Y.(*ir.Const)
if ok1 != ok2 {
continue
}
if !ok1 {
rem, ok1 = cmp.Y.(*ir.BinOp)
k, ok2 = cmp.X.(*ir.Const)
}
if !ok1 || !ok2 || rem.Op != token.REM || k.Value.Kind() != constant.Int || k.Uint64() != needle {
continue
}
k, ok = rem.Y.(*ir.Const)
if !ok || k.Value.Kind() != constant.Int || k.Uint64() != 2 {
continue
}
// if len(foo) % 2 != 0
call, ok := rem.X.(*ir.Call)
if !ok || !irutil.IsCallTo(call.Common(), "len") {
continue
}
// we're checking the length of a parameter that is a slice
// TODO(dh): support parameters that have flown through sigmas and phis
param, ok := call.Call.Args[0].(*ir.Parameter)
if !ok {
continue
}
if _, ok := param.Type().Underlying().(*types.Slice); !ok {
continue
}
// if len(foo) % 2 != 0 then panic
if _, ok := b.Succs[0].Control().(*ir.Panic); !ok {
continue
}
pass.ExportObjectFact(param.Object(), new(evenElements))
}
}
}
func findIndirectSliceLenChecks(pass *analysis.Pass) {
seen := map[*ir.Function]struct{}{}
var doFunction func(fn *ir.Function)
doFunction = func(fn *ir.Function) {
if _, ok := seen[fn]; ok {
return
}
seen[fn] = struct{}{}
for _, b := range fn.Blocks {
// all paths go through this block
if !b.Dominates(fn.Exit) {
continue
}
for _, instr := range b.Instrs {
call, ok := instr.(*ir.Call)
if !ok {
continue
}
callee := call.Call.StaticCallee()
if callee == nil {
continue
}
if callee.Pkg == fn.Pkg {
// TODO(dh): are we missing interesting wrappers
// because wrappers don't have Pkg set?
doFunction(callee)
}
for argi, arg := range call.Call.Args {
if callee.Signature.Recv() != nil {
if argi == 0 {
continue
}
argi--
}
// TODO(dh): support parameters that have flown through sigmas and phis
param, ok := arg.(*ir.Parameter)
if !ok {
continue
}
if _, ok := param.Type().Underlying().(*types.Slice); !ok {
continue
}
// We can't use callee.Params to look up the
// parameter, because Params is not populated for
// external functions. In our modular analysis.
// any function in any package that isn't the
// current package is considered "external", as it
// has been loaded from export data only.
sigParams := callee.Signature.Params()
if !pass.ImportObjectFact(sigParams.At(argi), new(evenElements)) {
continue
}
pass.ExportObjectFact(param.Object(), new(evenElements))
}
}
}
}
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
doFunction(fn)
}
}
func findSliceLength(v ir.Value) int {
// TODO(dh): VRP would help here
v = irutil.Flatten(v)
val := func(v ir.Value) int {
if v, ok := v.(*ir.Const); ok {
return int(v.Int64())
}
return -1
}
switch v := v.(type) {
case *ir.Slice:
low := 0
high := -1
if v.Low != nil {
low = val(v.Low)
}
if v.High != nil {
high = val(v.High)
} else {
switch vv := v.X.(type) {
case *ir.Alloc:
high = int(typeutil.Dereference(vv.Type()).Underlying().(*types.Array).Len())
case *ir.Slice:
high = findSliceLength(vv)
}
}
if low == -1 || high == -1 {
return -1
}
return high - low
default:
return -1
}
}
type evenElements struct{}
func (evenElements) AFact() {}
func (evenElements) String() string { return "needs even elements" }
func flagSliceLens(pass *analysis.Pass) {
var tag evenElements
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
for _, b := range fn.Blocks {
for _, instr := range b.Instrs {
call, ok := instr.(ir.CallInstruction)
if !ok {
continue
}
callee := call.Common().StaticCallee()
if callee == nil {
continue
}
for argi, arg := range call.Common().Args {
if callee.Signature.Recv() != nil {
if argi == 0 {
continue
}
argi--
}
_, ok := arg.Type().Underlying().(*types.Slice)
if !ok {
continue
}
param := callee.Signature.Params().At(argi)
if !pass.ImportObjectFact(param, &tag) {
continue
}
// TODO handle stubs
// we know the argument has to have even length.
// now let's try to find its length
if n := findSliceLength(arg); n > -1 && n%2 != 0 {
src := call.Source().(*ast.CallExpr).Args[argi]
sig := call.Common().Signature()
var label string
if argi == sig.Params().Len()-1 && sig.Variadic() {
label = "variadic argument"
} else {
label = "argument"
}
// Note that param.Name() is guaranteed to not
// be empty, otherwise the function couldn't
// have enforced its length.
report.Report(pass, src, fmt.Sprintf("%s %q is expected to have even number of elements, but has %d elements", label, param.Name(), n))
}
}
}
}
}
}
func CheckEvenSliceLength(pass *analysis.Pass) (interface{}, error) {
findSliceLenChecks(pass)
findIndirectSliceLenChecks(pass)
flagSliceLens(pass)
return nil, nil
}
func CheckTypedNilInterface(pass *analysis.Pass) (interface{}, error) {
// The comparison 'fn() == nil' can never be true if fn() returns
// an interface value and only returns typed nils. This is usually
// a mistake in the function itself, but all we can say for
// certain is that the comparison is pointless.
//
// Flag results if no untyped nils are being returned, but either
// known typed nils, or typed unknown nilness are being returned.
irpkg := pass.ResultOf[buildir.Analyzer].(*buildir.IR)
typedness := pass.ResultOf[typedness.Analysis].(*typedness.Result)
nilness := pass.ResultOf[nilness.Analysis].(*nilness.Result)
for _, fn := range irpkg.SrcFuncs {
for _, b := range fn.Blocks {
for _, instr := range b.Instrs {
binop, ok := instr.(*ir.BinOp)
if !ok || !(binop.Op == token.EQL || binop.Op == token.NEQ) {
continue
}
if _, ok := binop.X.Type().Underlying().(*types.Interface); !ok {
// TODO support swapped X and Y
continue
}
k, ok := binop.Y.(*ir.Const)
if !ok || !k.IsNil() {
// if binop.X is an interface, then binop.Y can
// only be a Const if its untyped. A typed nil
// constant would first be passed to
// MakeInterface.
continue
}
var idx int
var obj *types.Func
switch x := irutil.Flatten(binop.X).(type) {
case *ir.Call:
callee := x.Call.StaticCallee()
if callee == nil {
continue
}
obj, _ = callee.Object().(*types.Func)
idx = 0
case *ir.Extract:
call, ok := irutil.Flatten(x.Tuple).(*ir.Call)
if !ok {
continue
}
callee := call.Call.StaticCallee()
if callee == nil {
continue
}
obj, _ = callee.Object().(*types.Func)
idx = x.Index
case *ir.MakeInterface:
var qualifier string
switch binop.Op {
case token.EQL:
qualifier = "never"
case token.NEQ:
qualifier = "always"
default:
panic("unreachable")
}
if report.HasRange(x.X) {
report.Report(pass, binop, fmt.Sprintf("this comparison is %s true", qualifier),
report.Related(x.X, "the lhs of the comparison gets its value from here and has a concrete type"))
} else {
// we can't generate related information for this, so make the diagnostic itself slightly more useful
report.Report(pass, binop, fmt.Sprintf("this comparison is %s true; the lhs of the comparison has been assigned a concretely typed value", qualifier))
}
continue
}
if obj == nil {
continue
}
isNil, onlyGlobal := nilness.MayReturnNil(obj, idx)
if typedness.MustReturnTyped(obj, idx) && isNil && !onlyGlobal && !code.IsInTest(pass, binop) {
// Don't flag these comparisons in tests. Tests
// may be explicitly enforcing the invariant that
// a value isn't nil.
var qualifier string
switch binop.Op {
case token.EQL:
qualifier = "never"
case token.NEQ:
qualifier = "always"
default:
panic("unreachable")
}
report.Report(pass, binop, fmt.Sprintf("this comparison is %s true", qualifier),
// TODO support swapped X and Y
report.Related(binop.X, fmt.Sprintf("the lhs of the comparison is the %s return value of this function call", report.Ordinal(idx+1))),
report.Related(obj, fmt.Sprintf("%s never returns a nil interface value", typeutil.FuncName(obj))))
}
}
}
}
return nil, nil
}
var builtinLessThanZeroQ = pattern.MustParse(`
(Or
(BinaryExpr
(BasicLit "INT" "0")
">"
(CallExpr builtin@(Builtin (Or "len" "cap")) _))
(BinaryExpr
(CallExpr builtin@(Builtin (Or "len" "cap")) _)
"<"
(BasicLit "INT" "0")))
`)
func CheckBuiltinZeroComparison(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
matcher, ok := code.Match(pass, builtinLessThanZeroQ, node)
if !ok {
return
}
builtin := matcher.State["builtin"].(*ast.Ident)
report.Report(pass, node, fmt.Sprintf("builtin function %s does not return negative values", builtin.Name))
}
code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
return nil, nil
}
var integerDivisionQ = pattern.MustParse(`(BinaryExpr (BasicLit "INT" _) "/" (BasicLit "INT" _))`)
func CheckIntegerDivisionEqualsZero(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
_, ok := code.Match(pass, integerDivisionQ, node)
if !ok {
return
}
val := constant.ToInt(pass.TypesInfo.Types[node.(ast.Expr)].Value)
if v, ok := constant.Uint64Val(val); ok && v == 0 {
report.Report(pass, node, fmt.Sprintf("the integer division '%s' results in zero", report.Render(pass, node)))
}
// TODO: we could offer a suggested fix here, but I am not
// sure what it should be. There are many options to choose
// from.
// Note: we experimented with flagging divisions that truncate
// (e.g. 4 / 3), but it ran into false positives in Go's
// 'time' package, which does this, deliberately:
//
// unixToInternal int64 = (1969*365 + 1969/4 - 1969/100 + 1969/400) * secondsPerDay
//
// The check also found a real bug in other code, but I don't
// think we can outright ban this kind of division.
}
code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
return nil, nil
}
func CheckIneffectiveFieldAssignments(pass *analysis.Pass) (interface{}, error) {
// The analysis only considers the receiver and its first level
// fields. It doesn't look at other parameters, nor at nested
// fields.
//
// The analysis does not detect all kinds of dead stores, only
// those of fields that are never read after the write. That is,
// we do not flag 'a.x = 1; a.x = 2; _ = a.x'. We might explore
// this again if we add support for SROA to go/ir and implement
// https://github.com/dominikh/go-tools/issues/191.
irpkg := pass.ResultOf[buildir.Analyzer].(*buildir.IR)
fnLoop:
for _, fn := range irpkg.SrcFuncs {
if recv := fn.Signature.Recv(); recv == nil {
continue
} else if _, ok := recv.Type().Underlying().(*types.Struct); !ok {
continue
}
recv := fn.Params[0]
refs := irutil.FilterDebug(*recv.Referrers())
if len(refs) != 1 {
continue
}
store, ok := refs[0].(*ir.Store)
if !ok {
continue
}
alloc, ok := store.Addr.(*ir.Alloc)
if !ok || alloc.Heap {
continue
}
reads := map[int][]ir.Instruction{}
writes := map[int][]ir.Instruction{}
for _, ref := range *alloc.Referrers() {
switch ref := ref.(type) {
case *ir.FieldAddr:
for _, refref := range *ref.Referrers() {
switch refref.(type) {
case *ir.Store:
writes[ref.Field] = append(writes[ref.Field], refref)
case *ir.Load:
reads[ref.Field] = append(reads[ref.Field], refref)
case *ir.DebugRef:
continue
default:
// this should be safe⦠if the field address
// escapes, then alloc.Heap will be true.
// there should be no instructions left that,
// given this FieldAddr, without escaping, can
// effect a load or store.
continue
}
}
case *ir.Store:
// we could treat this as a store to every field, but
// we don't want to decide the semantics of partial
// struct initializers. should `v = t{x: 1}` also mark
// v.y as being written to?
if ref != store {
continue fnLoop
}
case *ir.Load:
// a load of the entire struct loads every field
for i := 0; i < recv.Type().Underlying().(*types.Struct).NumFields(); i++ {
reads[i] = append(reads[i], ref)
}
case *ir.DebugRef:
continue
default:
continue fnLoop
}
}
offset := func(instr ir.Instruction) int {
for i, other := range instr.Block().Instrs {
if instr == other {
return i
}
}
panic("couldn't find instruction in its block")
}
for field, ws := range writes {
rs := reads[field]
wLoop:
for _, w := range ws {
for _, r := range rs {
if w.Block() == r.Block() {
if offset(r) > offset(w) {
// found a reachable read of our write
continue wLoop
}
} else if irutil.Reachable(w.Block(), r.Block()) {
// found a reachable read of our write
continue wLoop
}
}
fieldName := recv.Type().Underlying().(*types.Struct).Field(field).Name()
report.Report(pass, w, fmt.Sprintf("ineffective assignment to field %s.%s", recv.Type().(*types.Named).Obj().Name(), fieldName))
}
}
}
return nil, nil
}
var negativeZeroFloatQ = pattern.MustParse(`
(Or
(UnaryExpr
"-"
(BasicLit "FLOAT" "0.0"))
(UnaryExpr
"-"
(CallExpr conv@(Object (Or "float32" "float64")) lit@(Or (BasicLit "INT" "0") (BasicLit "FLOAT" "0.0"))))
(CallExpr
conv@(Object (Or "float32" "float64"))
(UnaryExpr "-" lit@(BasicLit "INT" "0"))))`)
func CheckNegativeZeroFloat(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
m, ok := code.Match(pass, negativeZeroFloatQ, node)
if !ok {
return
}
if conv, ok := m.State["conv"].(*types.TypeName); ok {
var replacement string
// TODO(dh): how does this handle type aliases?
if conv.Name() == "float32" {
replacement = `float32(math.Copysign(0, -1))`
} else {
replacement = `math.Copysign(0, -1)`
}
report.Report(pass, node,
fmt.Sprintf("in Go, the floating-point expression '%s' is the same as '%s(%s)', it does not produce a negative zero",
report.Render(pass, node),
conv.Name(),
report.Render(pass, m.State["lit"])),
report.Fixes(edit.Fix("use math.Copysign to create negative zero", edit.ReplaceWithString(pass.Fset, node, replacement))))
} else {
const replacement = `math.Copysign(0, -1)`
report.Report(pass, node,
"in Go, the floating-point literal '-0.0' is the same as '0.0', it does not produce a negative zero",
report.Fixes(edit.Fix("use math.Copysign to create negative zero", edit.ReplaceWithString(pass.Fset, node, replacement))))
}
}
code.Preorder(pass, fn, (*ast.UnaryExpr)(nil), (*ast.CallExpr)(nil))
return nil, nil
}
var ineffectiveURLQueryAddQ = pattern.MustParse(`(CallExpr (SelectorExpr (CallExpr (SelectorExpr recv (Ident "Query")) []) (Ident meth)) _)`)
func CheckIneffectiveURLQueryModification(pass *analysis.Pass) (interface{}, error) {
// TODO(dh): We could make this check more complex and detect
// pointless modifications of net/url.Values in general, but that
// requires us to get the state machine correct, else we'll cause
// false positives.
fn := func(node ast.Node) {
m, ok := code.Match(pass, ineffectiveURLQueryAddQ, node)
if !ok {
return
}
if !code.IsOfType(pass, m.State["recv"].(ast.Expr), "*net/url.URL") {
return
}
switch m.State["meth"].(string) {
case "Add", "Del", "Set":
default:
return
}
report.Report(pass, node, "(*net/url.URL).Query returns a copy, modifying it doesn't change the URL")
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
go-tools-2021.1.2/staticcheck/lint_test.go 0000664 0000000 0000000 00000011747 14143223131 0020327 0 ustar 00root root 0000000 0000000 package staticcheck
import (
"testing"
"honnef.co/go/tools/lint/testutil"
)
func TestAll(t *testing.T) {
checks := map[string][]testutil.Test{
"SA1000": {{Dir: "CheckRegexps"}},
"SA1001": {{Dir: "CheckTemplate"}},
"SA1002": {{Dir: "CheckTimeParse"}},
"SA1003": {{Dir: "CheckEncodingBinary"}, {Dir: "CheckEncodingBinary_go17", Version: "1.7"}, {Dir: "CheckEncodingBinary_go18", Version: "1.8"}},
"SA1004": {{Dir: "CheckTimeSleepConstant"}},
"SA1005": {{Dir: "CheckExec"}},
"SA1006": {{Dir: "CheckUnsafePrintf"}},
"SA1007": {{Dir: "CheckURLs"}},
"SA1008": {{Dir: "CheckCanonicalHeaderKey"}},
"SA1010": {{Dir: "checkStdlibUsageRegexpFindAll"}},
"SA1011": {{Dir: "checkStdlibUsageUTF8Cutset"}},
"SA1012": {{Dir: "checkStdlibUsageNilContext"}},
"SA1013": {{Dir: "checkStdlibUsageSeeker"}},
"SA1014": {{Dir: "CheckUnmarshalPointer"}},
"SA1015": {{Dir: "CheckLeakyTimeTick"}, {Dir: "CheckLeakyTimeTick-main"}},
"SA1016": {{Dir: "CheckUntrappableSignal"}},
"SA1017": {{Dir: "CheckUnbufferedSignalChan"}},
"SA1018": {{Dir: "CheckStringsReplaceZero"}},
"SA1019": {
{Dir: "CheckDeprecated"},
{Dir: "CheckDeprecated_go13", Version: "1.3"},
{Dir: "CheckDeprecated_go14", Version: "1.4"},
{Dir: "CheckDeprecated_go18", Version: "1.8"},
},
"SA1020": {{Dir: "CheckListenAddress"}},
"SA1021": {{Dir: "CheckBytesEqualIP"}},
"SA1023": {{Dir: "CheckWriterBufferModified"}},
"SA1024": {{Dir: "CheckNonUniqueCutset"}},
"SA1025": {{Dir: "CheckTimerResetReturnValue"}},
"SA1026": {{Dir: "CheckUnsupportedMarshal"}},
"SA1027": {{Dir: "CheckAtomicAlignment"}},
"SA1028": {{Dir: "CheckSortSlice"}},
"SA1029": {{Dir: "CheckWithValueKey"}},
"SA1030": {
{Dir: "CheckStrconv"},
{Dir: "CheckStrconv_go115", Version: "1.15"},
},
"SA2000": {{Dir: "CheckWaitgroupAdd"}},
"SA2001": {{Dir: "CheckEmptyCriticalSection"}},
"SA2002": {{Dir: "CheckConcurrentTesting"}},
"SA2003": {{Dir: "CheckDeferLock"}},
"SA3000": {
{Dir: "CheckTestMainExit-1_go14", Version: "1.4"},
{Dir: "CheckTestMainExit-2_go14", Version: "1.4"},
{Dir: "CheckTestMainExit-3_go14", Version: "1.4"},
{Dir: "CheckTestMainExit-4_go14", Version: "1.4"},
{Dir: "CheckTestMainExit-5_go14", Version: "1.4"},
{Dir: "CheckTestMainExit-1_go115", Version: "1.15"},
},
"SA3001": {{Dir: "CheckBenchmarkN"}},
"SA4000": {{Dir: "CheckLhsRhsIdentical"}},
"SA4001": {{Dir: "CheckIneffectiveCopy"}},
"SA4003": {{Dir: "CheckExtremeComparison"}},
"SA4004": {{Dir: "CheckIneffectiveLoop"}},
"SA4005": {{Dir: "CheckIneffectiveFieldAssignments"}},
"SA4006": {{Dir: "CheckUnreadVariableValues"}},
"SA4008": {{Dir: "CheckLoopCondition"}},
"SA4009": {{Dir: "CheckArgOverwritten"}},
"SA4010": {{Dir: "CheckIneffectiveAppend"}},
"SA4011": {{Dir: "CheckScopedBreak"}},
"SA4012": {{Dir: "CheckNaNComparison"}},
"SA4013": {{Dir: "CheckDoubleNegation"}},
"SA4014": {{Dir: "CheckRepeatedIfElse"}},
"SA4015": {{Dir: "CheckMathInt"}},
"SA4016": {{Dir: "CheckSillyBitwiseOps"}, {Dir: "CheckSillyBitwiseOps_shadowedIota"}, {Dir: "CheckSillyBitwiseOps_dotImport"}},
"SA4017": {{Dir: "CheckPureFunctions"}},
"SA4018": {{Dir: "CheckSelfAssignment"}},
"SA4019": {{Dir: "CheckDuplicateBuildConstraints"}},
"SA4020": {{Dir: "CheckUnreachableTypeCases"}},
"SA4021": {{Dir: "CheckSingleArgAppend"}},
"SA4022": {{Dir: "CheckAddressIsNil"}},
"SA4023": {
{Dir: "CheckTypedNilInterface"},
{Dir: "CheckTypedNilInterface/i26000"},
{Dir: "CheckTypedNilInterface/i27815"},
{Dir: "CheckTypedNilInterface/i28241"},
{Dir: "CheckTypedNilInterface/i31873"},
{Dir: "CheckTypedNilInterface/i33965"},
{Dir: "CheckTypedNilInterface/i33994"},
{Dir: "CheckTypedNilInterface/i35217"},
},
"SA4024": {{Dir: "CheckBuiltinZeroComparison"}},
"SA4025": {{Dir: "CheckIntegerDivisionEqualsZero"}},
"SA4026": {{Dir: "CheckNegativeZeroFloat"}},
"SA4027": {{Dir: "CheckIneffectiveURLQueryModification"}},
"SA5000": {{Dir: "CheckNilMaps"}},
"SA5001": {{Dir: "CheckEarlyDefer"}},
"SA5002": {{Dir: "CheckInfiniteEmptyLoop"}},
"SA5003": {{Dir: "CheckDeferInInfiniteLoop"}},
"SA5004": {{Dir: "CheckLoopEmptyDefault"}},
"SA5005": {{Dir: "CheckCyclicFinalizer"}},
"SA5007": {{Dir: "CheckInfiniteRecursion"}},
"SA5008": {{Dir: "CheckStructTags"}, {Dir: "CheckStructTags2"}, {Dir: "CheckStructTags3"}},
"SA5009": {{Dir: "CheckPrintf"}},
"SA5010": {{Dir: "CheckImpossibleTypeAssertion"}},
"SA5011": {{Dir: "CheckMaybeNil"}},
"SA5012": {{Dir: "CheckEvenSliceLength"}},
"SA6000": {{Dir: "CheckRegexpMatchLoop"}},
"SA6001": {{Dir: "CheckMapBytesKey"}},
"SA6002": {{Dir: "CheckSyncPoolValue"}},
"SA6003": {{Dir: "CheckRangeStringRunes"}},
"SA6005": {{Dir: "CheckToLowerToUpperComparison"}},
"SA9001": {{Dir: "CheckDubiousDeferInChannelRangeLoop"}},
"SA9002": {{Dir: "CheckNonOctalFileMode"}},
"SA9003": {{Dir: "CheckEmptyBranch"}},
"SA9004": {{Dir: "CheckMissingEnumTypesInDeclaration"}},
"SA9005": {{Dir: "CheckNoopMarshal"}},
"SA9006": {{Dir: "CheckStaticBitShift"}},
}
testutil.Run(t, Analyzers, checks)
}
go-tools-2021.1.2/staticcheck/rules.go 0000664 0000000 0000000 00000014051 14143223131 0017443 0 ustar 00root root 0000000 0000000 package staticcheck
import (
"fmt"
"go/constant"
"go/types"
"net"
"net/url"
"regexp"
"sort"
"strconv"
"strings"
"time"
"unicode/utf8"
"honnef.co/go/tools/analysis/code"
"honnef.co/go/tools/go/ir"
"honnef.co/go/tools/go/ir/irutil"
"honnef.co/go/tools/go/types/typeutil"
"golang.org/x/tools/go/analysis"
)
const (
MsgInvalidHostPort = "invalid port or service name in host:port pair"
MsgInvalidUTF8 = "argument is not a valid UTF-8 encoded string"
MsgNonUniqueCutset = "cutset contains duplicate characters"
)
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 CallCheck func(call *Call)
func extractConstExpectKind(v ir.Value, kind constant.Kind) *ir.Const {
k := extractConst(v)
if k == nil || k.Value == nil || k.Value.Kind() != kind {
return nil
}
return k
}
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
}
}
func ValidateRegexp(v Value) error {
if c := extractConstExpectKind(v.Value, constant.String); c != nil {
s := constant.StringVal(c.Value)
if _, err := regexp.Compile(s); err != nil {
return err
}
}
return nil
}
func ValidateTimeLayout(v Value) error {
if c := extractConstExpectKind(v.Value, constant.String); c != nil {
s := constant.StringVal(c.Value)
s = strings.Replace(s, "_", " ", -1)
s = strings.Replace(s, "Z", "-", -1)
_, err := time.Parse(s, s)
if err != nil {
return err
}
}
return nil
}
func ValidateURL(v Value) error {
if c := extractConstExpectKind(v.Value, constant.String); c != nil {
s := constant.StringVal(c.Value)
_, err := url.Parse(s)
if err != nil {
return fmt.Errorf("%q is not a valid URL: %s", s, err)
}
}
return nil
}
func InvalidUTF8(v Value) bool {
if c := extractConstExpectKind(v.Value, constant.String); c != nil {
s := constant.StringVal(c.Value)
if !utf8.ValidString(s) {
return true
}
}
return false
}
func UnbufferedChannel(v Value) bool {
// TODO(dh): this check of course misses many cases of unbuffered
// channels, such as any in phi or sigma nodes. We'll eventually
// replace this function.
val := v.Value
if ct, ok := val.(*ir.ChangeType); ok {
val = ct.X
}
mk, ok := val.(*ir.MakeChan)
if !ok {
return false
}
if k, ok := mk.Size.(*ir.Const); ok && k.Value.Kind() == constant.Int {
if v, ok := constant.Int64Val(k.Value); ok && v == 0 {
return true
}
}
return false
}
func Pointer(v Value) bool {
switch v.Value.Type().Underlying().(type) {
case *types.Pointer, *types.Interface:
return true
}
return false
}
func ConvertedFromInt(v Value) bool {
conv, ok := v.Value.(*ir.Convert)
if !ok {
return false
}
b, ok := conv.X.Type().Underlying().(*types.Basic)
if !ok {
return false
}
if (b.Info() & types.IsInteger) == 0 {
return false
}
return true
}
func validEncodingBinaryType(pass *analysis.Pass, typ types.Type) bool {
typ = typ.Underlying()
switch typ := typ.(type) {
case *types.Basic:
switch typ.Kind() {
case types.Uint8, types.Uint16, types.Uint32, types.Uint64,
types.Int8, types.Int16, types.Int32, types.Int64,
types.Float32, types.Float64, types.Complex64, types.Complex128, types.Invalid:
return true
case types.Bool:
return code.IsGoVersion(pass, 8)
}
return false
case *types.Struct:
n := typ.NumFields()
for i := 0; i < n; i++ {
if !validEncodingBinaryType(pass, typ.Field(i).Type()) {
return false
}
}
return true
case *types.Array:
return validEncodingBinaryType(pass, typ.Elem())
case *types.Interface:
// we can't determine if it's a valid type or not
return true
}
return false
}
func CanBinaryMarshal(pass *analysis.Pass, v Value) bool {
typ := v.Value.Type().Underlying()
if ttyp, ok := typ.(*types.Pointer); ok {
typ = ttyp.Elem().Underlying()
}
if ttyp, ok := typ.(interface {
Elem() types.Type
}); ok {
if _, ok := ttyp.(*types.Pointer); !ok {
typ = ttyp.Elem()
}
}
return validEncodingBinaryType(pass, typ)
}
func RepeatZeroTimes(name string, arg int) CallCheck {
return func(call *Call) {
arg := call.Args[arg]
if k, ok := arg.Value.Value.(*ir.Const); ok && k.Value.Kind() == constant.Int {
if v, ok := constant.Int64Val(k.Value); ok && v == 0 {
arg.Invalid(fmt.Sprintf("calling %s with n == 0 will return no results, did you mean -1?", name))
}
}
}
}
func validateServiceName(s string) bool {
if len(s) < 1 || len(s) > 15 {
return false
}
if s[0] == '-' || s[len(s)-1] == '-' {
return false
}
if strings.Contains(s, "--") {
return false
}
hasLetter := false
for _, r := range s {
if (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') {
hasLetter = true
continue
}
if r >= '0' && r <= '9' {
continue
}
return false
}
return hasLetter
}
func validatePort(s string) bool {
n, err := strconv.ParseInt(s, 10, 64)
if err != nil {
return validateServiceName(s)
}
return n >= 0 && n <= 65535
}
func ValidHostPort(v Value) bool {
if k := extractConstExpectKind(v.Value, constant.String); k != nil {
s := constant.StringVal(k.Value)
_, port, err := net.SplitHostPort(s)
if err != nil {
return false
}
// TODO(dh): check hostname
if !validatePort(port) {
return false
}
}
return true
}
// ConvertedFrom reports whether value v was converted from type typ.
func ConvertedFrom(v Value, typ string) bool {
change, ok := v.Value.(*ir.ChangeType)
return ok && typeutil.IsType(change.X.Type(), typ)
}
func UniqueStringCutset(v Value) bool {
if c := extractConstExpectKind(v.Value, constant.String); c != nil {
s := constant.StringVal(c.Value)
rs := runeSlice(s)
if len(rs) < 2 {
return true
}
sort.Sort(rs)
for i, r := range rs[1:] {
if rs[i] == r {
return false
}
}
}
return true
}
go-tools-2021.1.2/staticcheck/structtag.go 0000664 0000000 0000000 00000002470 14143223131 0020333 0 ustar 00root root 0000000 0000000 // Copyright 2009 The Go Authors. All rights reserved.
// Copyright 2019 Dominik Honnef. All rights reserved.
package staticcheck
import "strconv"
func parseStructTag(tag string) (map[string][]string, error) {
// FIXME(dh): detect missing closing quote
out := map[string][]string{}
for tag != "" {
// Skip leading space.
i := 0
for i < len(tag) && tag[i] == ' ' {
i++
}
tag = tag[i:]
if tag == "" {
break
}
// Scan to colon. A space, a quote or a control character is a syntax error.
// Strictly speaking, control chars include the range [0x7f, 0x9f], not just
// [0x00, 0x1f], but in practice, we ignore the multi-byte control characters
// as it is simpler to inspect the tag's bytes than the tag's runes.
i = 0
for i < len(tag) && tag[i] > ' ' && tag[i] != ':' && tag[i] != '"' && tag[i] != 0x7f {
i++
}
if i == 0 || i+1 >= len(tag) || tag[i] != ':' || tag[i+1] != '"' {
break
}
name := string(tag[:i])
tag = tag[i+1:]
// Scan quoted string to find value.
i = 1
for i < len(tag) && tag[i] != '"' {
if tag[i] == '\\' {
i++
}
i++
}
if i >= len(tag) {
break
}
qvalue := string(tag[:i+1])
tag = tag[i+1:]
value, err := strconv.Unquote(qvalue)
if err != nil {
return nil, err
}
out[name] = append(out[name], value)
}
return out, nil
}
go-tools-2021.1.2/staticcheck/testdata/ 0000775 0000000 0000000 00000000000 14143223131 0017572 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/ 0000775 0000000 0000000 00000000000 14143223131 0020361 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckAddressIsNil/ 0000775 0000000 0000000 00000000000 14143223131 0023643 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckAddressIsNil/CheckAddressIsNil.go 0000664 0000000 0000000 00000000433 14143223131 0027454 0 ustar 00root root 0000000 0000000 package pkg
func fn(x int, y *int) {
_ = &x == nil // want `the address of a variable cannot be nil`
_ = &y != nil // want `the address of a variable cannot be nil`
if &x != nil { // want `the address of a variable cannot be nil`
println("obviously.")
}
if y == nil {
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckArgOverwritten/ 0000775 0000000 0000000 00000000000 14143223131 0024301 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckArgOverwritten/CheckArgOverwritten.go 0000664 0000000 0000000 00000000124 14143223131 0030545 0 ustar 00root root 0000000 0000000 package pkg
var x = func(arg int) { // want `overwritten`
arg = 1
println(arg)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckAtomicAlignment/ 0000775 0000000 0000000 00000000000 14143223131 0024372 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckAtomicAlignment/atomic32.go 0000664 0000000 0000000 00000001010 14143223131 0026332 0 ustar 00root root 0000000 0000000 // +build 386 arm armbe mips mipsle ppc s390 sparc
package pkg
import "sync/atomic"
type T struct {
A int64
B int32
C int64
}
func fn() {
var v T
atomic.AddInt64(&v.A, 0)
atomic.AddInt64(&v.C, 0) // want `address of non 64-bit aligned field C passed to sync/atomic.AddInt64`
atomic.LoadInt64(&v.C) // want `address of non 64-bit aligned field C passed to sync/atomic.LoadInt64`
}
func fn2(t *T) {
addr := &t.C
if true {
atomic.LoadUint64(addr) // want `address of non 64-bit`
} else {
_ = addr
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckAtomicAlignment/atomic64.go 0000664 0000000 0000000 00000000420 14143223131 0026343 0 ustar 00root root 0000000 0000000 // +build amd64 amd64p32 arm64 ppc64 ppc64le mips64 mips64le mips64p32 mips64p32le sparc64
package pkg
import "sync/atomic"
type T struct {
A int64
B int32
C int64
}
func fn() {
var v T
atomic.AddInt64(&v.A, 0)
atomic.AddInt64(&v.C, 0)
atomic.LoadInt64(&v.C)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckBenchmarkN/ 0000775 0000000 0000000 00000000000 14143223131 0023327 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckBenchmarkN/CheckBenchmarkN.go 0000664 0000000 0000000 00000000164 14143223131 0026625 0 ustar 00root root 0000000 0000000 package foo
import "testing"
func foo() {
var b *testing.B
b.N = 1 // want `should not assign to b\.N`
_ = b
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckBuiltinZeroComparison/ 0000775 0000000 0000000 00000000000 14143223131 0025620 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckBuiltinZeroComparison/CheckBuiltinZeroComparison.go 0000664 0000000 0000000 00000001227 14143223131 0033410 0 ustar 00root root 0000000 0000000 package pkg
func fn1() {
var foo []int
if len(foo) < 0 { // want `len does not return negative values`
println("test")
}
switch {
case len(foo) < 0: // want `negative`
println("test")
}
for len(foo) < 0 { // want `negative`
println("test")
}
println(len(foo) < 0) // want `negative`
if 0 > cap(foo) { // want `cap does not return negative values`
println("test")
}
switch {
case 0 > cap(foo): // want `negative`
println("test")
}
for 0 > cap(foo) { // want `negative`
println("test")
}
println(0 > cap(foo)) // want `negative`
}
func fn2() {
const zero = 0
var foo []int
println(len(foo) < zero)
println(len(foo) < 1)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckBytesEqualIP/ 0000775 0000000 0000000 00000000000 14143223131 0023626 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckBytesEqualIP/CheckBytesEqualIP.go 0000664 0000000 0000000 00000000450 14143223131 0027421 0 ustar 00root root 0000000 0000000 package pkg
import (
"bytes"
"net"
)
func fn() {
type T []byte
var i1, i2 net.IP
var b1, b2 []byte
var t1, t2 T
bytes.Equal(i1, i2) // want `use net\.IP\.Equal to compare net\.IPs, not bytes\.Equal`
bytes.Equal(b1, b2)
bytes.Equal(t1, t2)
bytes.Equal(i1, b1)
bytes.Equal(b1, i1)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckCanonicalHeaderKey/ 0000775 0000000 0000000 00000000000 14143223131 0024770 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckCanonicalHeaderKey/CheckCanonicalHeaderKey.go 0000664 0000000 0000000 00000000576 14143223131 0031736 0 ustar 00root root 0000000 0000000 package pkg
import "net/http"
func fn() {
const hdr = "foo"
var r http.Request
h := http.Header{}
var m map[string][]string
_ = h["foo"] // want `keys in http\.Header are canonicalized`
_ = h[hdr] // want `keys in http\.Header are canonicalized`
h["foo"] = nil
_ = r.Header["foo"] // want `keys in http\.Header are canonicalized`
r.Header["foo"] = nil
_ = m["foo"]
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckCanonicalHeaderKey/CheckCanonicalHeaderKey.go.golden0000664 0000000 0000000 00000000654 14143223131 0033202 0 ustar 00root root 0000000 0000000 package pkg
import "net/http"
func fn() {
const hdr = "foo"
var r http.Request
h := http.Header{}
var m map[string][]string
_ = h["Foo"] // want `keys in http\.Header are canonicalized`
_ = h[http.CanonicalHeaderKey(hdr)] // want `keys in http\.Header are canonicalized`
h["foo"] = nil
_ = r.Header["Foo"] // want `keys in http\.Header are canonicalized`
r.Header["foo"] = nil
_ = m["foo"]
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckConcurrentTesting/ 0000775 0000000 0000000 00000000000 14143223131 0024777 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckConcurrentTesting/CheckConcurrentTesting.go 0000664 0000000 0000000 00000001165 14143223131 0031747 0 ustar 00root root 0000000 0000000 package pkg
import "testing"
func fn1() {
var t *testing.T
go func() { // want `the goroutine calls T\.Fatal, which must be called in the same goroutine as the test`
t.Fatal()
}()
go fn2(t) // want `the goroutine calls T\.Fatal, which must be called in the same goroutine as the test`
fn := func() {
t.Fatal()
}
go fn() // want `the goroutine calls T\.Fatal, which must be called in the same goroutine as the test`
}
func fn2(t *testing.T) {
t.Fatal()
}
func fn3(t *testing.T) {
fn := func() {
t.Fatal()
}
fn()
}
func fn4(t *testing.T) {
t.Fatal()
}
func fn5(t *testing.T) {
func() {
t.Fatal()
}()
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckCyclicFinalizer/ 0000775 0000000 0000000 00000000000 14143223131 0024371 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckCyclicFinalizer/CheckCyclicFinalizer.go 0000664 0000000 0000000 00000001072 14143223131 0030730 0 ustar 00root root 0000000 0000000 package pkg
import (
"fmt"
"runtime"
)
func fn() {
var x *int
foo := func(y *int) { fmt.Println(x) }
runtime.SetFinalizer(x, foo) // want `the finalizer closes over the object, preventing the finalizer from ever running \(at .+:10:9`
runtime.SetFinalizer(x, nil)
runtime.SetFinalizer(x, func(_ *int) { // want `the finalizer closes over the object, preventing the finalizer from ever running \(at .+:13:26`
fmt.Println(x)
})
foo = func(y *int) { fmt.Println(y) }
runtime.SetFinalizer(x, foo)
runtime.SetFinalizer(x, func(y *int) {
fmt.Println(y)
})
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckDeferInInfiniteLoop/ 0000775 0000000 0000000 00000000000 14143223131 0025153 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckDeferInInfiniteLoop/CheckDeferInInfiniteLoop.go 0000664 0000000 0000000 00000001010 14143223131 0032264 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
for {
defer println() // want `will never run`
}
for {
defer println() // want `will never run`
go func() {
return
}()
}
for {
defer println()
return
}
for false {
defer println()
}
for {
defer println()
break
}
for {
defer println()
if true {
break
}
}
for {
defer println()
// Right now, we treat every break the same. We could analyse
// this further and see, that the break doesn't break out of
// the outer loop.
for {
break
}
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckDeferLock/ 0000775 0000000 0000000 00000000000 14143223131 0023155 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckDeferLock/CheckDeferLock.go 0000664 0000000 0000000 00000000776 14143223131 0026312 0 ustar 00root root 0000000 0000000 package pkg
import "sync"
var r sync.Mutex
var rw sync.RWMutex
func fn1() {
r.Lock()
defer r.Lock() // want `deferring Lock right after having locked already; did you mean to defer Unlock`
}
func fn2() {
r.Lock()
defer r.Unlock()
}
func fn3() {
println("")
defer r.Lock()
}
func fn4() {
rw.RLock()
defer rw.RLock() // want `deferring RLock right after having locked already; did you mean to defer RUnlock`
}
func fn5() {
rw.RLock()
defer rw.Lock()
}
func fn6() {
r.Lock()
defer rw.Lock()
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckDeprecated/ 0000775 0000000 0000000 00000000000 14143223131 0023357 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckDeprecated/CheckDeprecated.go 0000664 0000000 0000000 00000000577 14143223131 0026715 0 ustar 00root root 0000000 0000000 package pkg
import _ "CheckDeprecatedassist" // want `Alas, it is deprecated\.`
import _ "AnotherCheckDeprecatedassist" // want `Alas, it is deprecated\.`
import foo "AnotherCheckDeprecatedassist" // want `Alas, it is deprecated\.`
import "AnotherCheckDeprecatedassist" // want `Alas, it is deprecated\.`
func init() {
foo.Fn()
AnotherCheckDeprecatedassist.Fn()
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckDeprecated/not-protobuf.go 0000664 0000000 0000000 00000000134 14143223131 0026342 0 ustar 00root root 0000000 0000000 package pkg
import _ "github.com/golang/protobuf/proto" // want `Alas, it is deprecated\.`
go-tools-2021.1.2/staticcheck/testdata/src/CheckDeprecated/protobuf.go 0000664 0000000 0000000 00000000153 14143223131 0025545 0 ustar 00root root 0000000 0000000 // Code generated by protoc-gen-go. DO NOT EDIT.
package pkg
import _ "github.com/golang/protobuf/proto"
go-tools-2021.1.2/staticcheck/testdata/src/CheckDeprecated/vendor/ 0000775 0000000 0000000 00000000000 14143223131 0024654 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckDeprecated/vendor/AnotherCheckDeprecatedassist/ 0000775 0000000 0000000 00000000000 14143223131 0032422 5 ustar 00root root 0000000 0000000 CheckDeprecatedassist.go 0000664 0000000 0000000 00000000177 14143223131 0037124 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckDeprecated/vendor/AnotherCheckDeprecatedassist // Package pkg is a nice package.
//
// Deprecated: Alas, it is deprecated.
package AnotherCheckDeprecatedassist
func Fn() {}
go-tools-2021.1.2/staticcheck/testdata/src/CheckDeprecated_go13/ 0000775 0000000 0000000 00000000000 14143223131 0024210 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckDeprecated_go13/CheckDeprecated.go 0000664 0000000 0000000 00000001147 14143223131 0027540 0 ustar 00root root 0000000 0000000 package pkg
import (
"crypto/x509"
"net/http/httputil"
"path/filepath"
)
func fn() {
filepath.HasPrefix("", "") // want `filepath.HasPrefix has been deprecated since Go 1.0 because it shouldn't be used:`
_ = httputil.ErrPersistEOF // want `httputil.ErrPersistEOF has been deprecated since Go 1.0:`
_ = httputil.ServerConn{} // want `httputil.ServerConn has been deprecated since Go 1.0:`
_ = x509.CertificateRequest{}.Attributes // want `x509.CertificateRequest{}.Attributes has been deprecated since Go 1.5 and an alternative has been available since Go 1.3:`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckDeprecated_go14/ 0000775 0000000 0000000 00000000000 14143223131 0024211 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckDeprecated_go14/CheckDeprecated.go 0000664 0000000 0000000 00000001242 14143223131 0027535 0 ustar 00root root 0000000 0000000 package pkg
import (
"compress/flate"
"database/sql/driver"
"net/http"
"os"
"syscall"
)
var _ = syscall.StringByteSlice("") // want `Use ByteSliceFromString instead`
func fn1(err error) {
var r *http.Request
_ = r.Cancel // want `If a Request's Cancel field and context are both`
_ = syscall.StringByteSlice("") // want `Use ByteSliceFromString instead`
_ = os.SEEK_SET
var _ flate.ReadError
var tr *http.Transport
tr.CancelRequest(nil)
var conn driver.Conn
conn.Begin()
}
// Deprecated: Don't use this.
func fn2() {
_ = syscall.StringByteSlice("")
anon := func(x int) {
println(x)
_ = syscall.StringByteSlice("")
}
anon(1)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckDeprecated_go18/ 0000775 0000000 0000000 00000000000 14143223131 0024215 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckDeprecated_go18/CheckDeprecated.go 0000664 0000000 0000000 00000002037 14143223131 0027544 0 ustar 00root root 0000000 0000000 package pkg
import (
"compress/flate"
"database/sql/driver"
"net/http"
"os"
"syscall"
)
var _ = syscall.StringByteSlice("") // want `Use ByteSliceFromString instead`
func fn1(err error) {
var r *http.Request
_ = r.Cancel // want `If a Request's Cancel field and context are both`
_ = syscall.StringByteSlice("") // want `Use ByteSliceFromString instead`
_ = os.SEEK_SET // want `Use io\.SeekStart, io\.SeekCurrent, and io\.SeekEnd`
if err == http.ErrWriteAfterFlush { // want `ErrWriteAfterFlush is no longer`
println()
}
var _ flate.ReadError // want `No longer returned`
var tr *http.Transport
tr.CancelRequest(nil) // want `CancelRequest has been deprecated`
var conn driver.Conn
conn.Begin() // want `Begin has been deprecated`
}
// Deprecated: Don't use this.
func fn2() {
_ = syscall.StringByteSlice("")
anon := func(x int) {
println(x)
_ = syscall.StringByteSlice("")
anon := func(x int) {
println(x)
_ = syscall.StringByteSlice("")
}
anon(2)
}
anon(1)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckDeprecatedassist/ 0000775 0000000 0000000 00000000000 14143223131 0024606 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckDeprecatedassist/CheckDeprecatedassist.go 0000664 0000000 0000000 00000000130 14143223131 0031354 0 ustar 00root root 0000000 0000000 // Package pkg is a nice package.
//
// Deprecated: Alas, it is deprecated.
package pkg
go-tools-2021.1.2/staticcheck/testdata/src/CheckDoubleNegation/ 0000775 0000000 0000000 00000000000 14143223131 0024216 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckDoubleNegation/CheckDoubleNegation.go 0000664 0000000 0000000 00000000442 14143223131 0030402 0 ustar 00root root 0000000 0000000 package pkg
func fn(b1, b2 bool) {
if !!b1 { // want `negating a boolean twice`
println()
}
if b1 && !!b2 { // want `negating a boolean twice`
println()
}
if !(!b1) { // want `negating a boolean twice`
println()
}
if !b1 {
println()
}
if !b1 && !b2 {
println()
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckDoubleNegation/CheckDoubleNegation.go.golden 0000664 0000000 0000000 00000001165 14143223131 0031654 0 ustar 00root root 0000000 0000000 -- turn into single negation --
package pkg
func fn(b1, b2 bool) {
if !b1 { // want `negating a boolean twice`
println()
}
if b1 && !b2 { // want `negating a boolean twice`
println()
}
if !b1 { // want `negating a boolean twice`
println()
}
if !b1 {
println()
}
if !b1 && !b2 {
println()
}
}
-- remove double negation --
package pkg
func fn(b1, b2 bool) {
if b1 { // want `negating a boolean twice`
println()
}
if b1 && b2 { // want `negating a boolean twice`
println()
}
if b1 { // want `negating a boolean twice`
println()
}
if !b1 {
println()
}
if !b1 && !b2 {
println()
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckDubiousDeferInChannelRangeLoop/ 0000775 0000000 0000000 00000000000 14143223131 0027266 5 ustar 00root root 0000000 0000000 CheckDubiousDeferInChannelRangeLoop.go 0000664 0000000 0000000 00000000165 14143223131 0036445 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckDubiousDeferInChannelRangeLoop package pkg
func fn() {
var ch chan int
for range ch {
defer println() // want `defers in this range loop`
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckDuplicateBuildConstraints/ 0000775 0000000 0000000 00000000000 14143223131 0026441 5 ustar 00root root 0000000 0000000 CheckDuplicateBuildConstraints.go 0000664 0000000 0000000 00000000157 14143223131 0034774 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckDuplicateBuildConstraints // +build one two three go1.1
// +build three one two go1.1
package pkg // want `identical build constraints`
go-tools-2021.1.2/staticcheck/testdata/src/CheckEarlyDefer/ 0000775 0000000 0000000 00000000000 14143223131 0023341 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckEarlyDefer/CheckEarlyDefer.go 0000664 0000000 0000000 00000001047 14143223131 0026652 0 ustar 00root root 0000000 0000000 package pkg
import "io"
func fn1() (io.ReadCloser, error) {
return nil, nil
}
type T struct {
rc io.ReadCloser
}
func fn3() (T, error) {
return T{}, nil
}
func fn2() {
rc, err := fn1()
defer rc.Close() // want `should check returned error before deferring rc\.Close`
if err != nil {
println()
}
rc, _ = fn1()
defer rc.Close()
rc, err = fn1()
if err != nil {
println()
}
defer rc.Close()
t, err := fn3()
defer t.rc.Close() // want `should check returned error before deferring t\.rc\.Close`
if err != nil {
println()
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckEmptyBranch/ 0000775 0000000 0000000 00000000000 14143223131 0023533 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckEmptyBranch/CheckEmptyBranch.go 0000664 0000000 0000000 00000000570 14143223131 0027236 0 ustar 00root root 0000000 0000000 package pkg
func fn1() {
if true { // want `empty branch`
}
if true { // want `empty branch`
} else { // want `empty branch`
}
if true {
println()
}
if true {
println()
} else { // want `empty branch`
}
if true { // want `empty branch`
// TODO handle error
}
if true {
} else {
println()
}
if true {
} else if false { // want `empty branch`
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckEmptyBranch/CheckEmptyBranch_generated.go 0000664 0000000 0000000 00000000126 14143223131 0031251 0 ustar 00root root 0000000 0000000 // Code generated by a human. DO NOT EDIT.
package pkg
func fn2() {
if true {
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckEmptyBranch/CheckEmptyBranch_test.go 0000664 0000000 0000000 00000000234 14143223131 0030272 0 ustar 00root root 0000000 0000000 package pkg
import "testing"
func TestFoo(t *testing.T) {
if true { // want `empty branch`
// TODO
}
}
func ExampleFoo() {
if true {
// TODO
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckEmptyCriticalSection/ 0000775 0000000 0000000 00000000000 14143223131 0025415 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckEmptyCriticalSection/CheckEmptyCriticalSection.go 0000664 0000000 0000000 00000002322 14143223131 0032777 0 ustar 00root root 0000000 0000000 package pkg
import "sync"
func fn1() {
var x sync.Mutex
x.Lock()
x.Unlock() // want `empty critical section`
}
func fn2() {
x := struct {
m1 struct {
m2 sync.Mutex
}
}{}
x.m1.m2.Lock()
x.m1.m2.Unlock() // want `empty critical section`
}
func fn3() {
var x sync.RWMutex
x.Lock()
x.Unlock() // want `empty critical section`
x.RLock()
x.RUnlock() // want `empty critical section`
x.Lock()
defer x.Unlock()
}
func fn4() {
x := struct {
m func() *sync.Mutex
}{
m: func() *sync.Mutex {
return new(sync.Mutex)
},
}
x.m().Lock()
x.m().Unlock() // want `empty critical section`
}
func fn5() {
i := 0
var x sync.Mutex
x.Lock()
i++
x.Unlock()
}
func fn6() {
x := &sync.Mutex{}
x.Lock()
x.Unlock() // want `empty critical section`
}
func fn7() {
x := &struct {
sync.Mutex
}{}
x.Lock()
x.Unlock() // want `empty critical section`
}
func fn8() {
var x sync.Locker
x = new(sync.Mutex)
x.Lock()
x.Unlock() // want `empty critical section`
}
func fn9() {
x := &struct {
sync.Locker
}{&sync.Mutex{}}
x.Lock()
x.Unlock() // want `empty critical section`
}
type T struct{}
func (T) Lock() int { return 0 }
func (T) Unlock() {}
func fn10() {
var t T
t.Lock()
t.Unlock()
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckEncodingBinary/ 0000775 0000000 0000000 00000000000 14143223131 0024212 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckEncodingBinary/CheckEncodingBinary.go 0000664 0000000 0000000 00000004052 14143223131 0030373 0 ustar 00root root 0000000 0000000 package pkg
import (
"encoding/binary"
"io"
"io/ioutil"
"log"
)
func fn() {
type T1 struct {
A int32
}
type T2 struct {
A int32
B int
}
type T3 struct {
A []int32
}
type T4 struct {
A *int32
}
type T5 struct {
A int32
}
type T6 []byte
var x1 int
var x2 int32
var x3 []int
var x4 []int32
var x5 [1]int
var x6 [1]int32
var x7 T1
var x8 T2
var x9 T3
var x10 T4
var x11 = &T5{}
var x13 []byte
var x14 *[]byte
var x15 T6
log.Println(binary.Write(ioutil.Discard, binary.LittleEndian, x1)) // want `cannot be used with binary\.Write`
log.Println(binary.Write(ioutil.Discard, binary.LittleEndian, x2))
log.Println(binary.Write(ioutil.Discard, binary.LittleEndian, x3)) // want `cannot be used with binary\.Write`
log.Println(binary.Write(ioutil.Discard, binary.LittleEndian, x4))
log.Println(binary.Write(ioutil.Discard, binary.LittleEndian, x5)) // want `cannot be used with binary\.Write`
log.Println(binary.Write(ioutil.Discard, binary.LittleEndian, x6))
log.Println(binary.Write(ioutil.Discard, binary.LittleEndian, x7))
log.Println(binary.Write(ioutil.Discard, binary.LittleEndian, x8)) // want `cannot be used with binary\.Write`
log.Println(binary.Write(ioutil.Discard, binary.LittleEndian, x9)) // want `cannot be used with binary\.Write`
log.Println(binary.Write(ioutil.Discard, binary.LittleEndian, x10)) // want `cannot be used with binary\.Write`
log.Println(binary.Write(ioutil.Discard, binary.LittleEndian, x11))
log.Println(binary.Write(ioutil.Discard, binary.LittleEndian, &x13))
log.Println(binary.Write(ioutil.Discard, binary.LittleEndian, &x14)) // want `cannot be used with binary\.Write`
log.Println(binary.Write(ioutil.Discard, binary.LittleEndian, x15))
log.Println(binary.Write(ioutil.Discard, binary.LittleEndian, &x15))
log.Println(binary.Write(fn2())) // want `cannot be used with binary\.Write`
log.Println(binary.Write(fn3()))
}
func fn2() (io.Writer, binary.ByteOrder, int) { return nil, binary.LittleEndian, 0 }
func fn3() (io.Writer, binary.ByteOrder, uint32) { return nil, binary.LittleEndian, 0 }
go-tools-2021.1.2/staticcheck/testdata/src/CheckEncodingBinary_go17/ 0000775 0000000 0000000 00000000000 14143223131 0025047 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckEncodingBinary_go17/CheckEncodingBinary.go 0000664 0000000 0000000 00000000311 14143223131 0031222 0 ustar 00root root 0000000 0000000 package pkg
import (
"encoding/binary"
"io/ioutil"
"log"
)
func fn() {
var x bool
log.Println(binary.Write(ioutil.Discard, binary.LittleEndian, x)) // want `cannot be used with binary\.Write`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckEncodingBinary_go18/ 0000775 0000000 0000000 00000000000 14143223131 0025050 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckEncodingBinary_go18/CheckEncodingBinary.go 0000664 0000000 0000000 00000000211 14143223131 0031222 0 ustar 00root root 0000000 0000000 package pkg
import (
"encoding/binary"
"io/ioutil"
)
func fn() {
var x bool
binary.Write(ioutil.Discard, binary.LittleEndian, x)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckEvenSliceLength/ 0000775 0000000 0000000 00000000000 14143223131 0024336 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckEvenSliceLength/CheckEvenSliceLength.go 0000664 0000000 0000000 00000004322 14143223131 0030643 0 ustar 00root root 0000000 0000000 package pkg
import "strings"
func fnVariadic(s string, args ...interface{}) { // want args:"needs even elements"
if len(args)%2 != 0 {
panic("I'm one of those annoying logging APIs")
}
}
func fnSlice(s string, args []interface{}) { // want args:"needs even elements"
if len(args)%2 != 0 {
panic("I'm one of those annoying logging APIs")
}
}
func fnIndirect(s string, args ...interface{}) { // want args:"needs even elements"
fnSlice(s, args)
}
func fn2(bleh []interface{}, arr1 [3]interface{}) { // want bleh:"needs even elements"
fnVariadic("%s", 1, 2, 3) // want `variadic argument "args".+ but has 3 elements`
args := []interface{}{1, 2, 3}
fnVariadic("", args...) // want `variadic argument "args".+ but has 3 elements`
fnVariadic("", args[:1]...) // want `variadic argument "args".+ but has 1 elements`
fnVariadic("", args[:2]...)
fnVariadic("", args[0:1]...) // want `variadic argument "args".+ but has 1 elements`
fnVariadic("", args[0:]...) // want `variadic argument "args".+ but has 3 elements`
fnVariadic("", args[:]...) // want `variadic argument "args".+ but has 3 elements`
fnVariadic("", bleh...)
fnVariadic("", bleh[:1]...) // want `variadic argument "args".+ but has 1 elements`
fnVariadic("", bleh[0:1]...) // want `variadic argument "args".+ but has 1 elements`
fnVariadic("", bleh[0:]...)
fnVariadic("", bleh[:]...)
fnVariadic("", bleh) // want `variadic argument "args".+ but has 1 elements`
fnVariadic("", make([]interface{}, 3)...) // want `variadic argument "args".+ but has 3 elements`
fnVariadic("", make([]interface{}, 4)...)
var arr2 [3]interface{}
fnVariadic("", arr1[:]...) // want `variadic argument "args".+ but has 3 elements`
fnVariadic("", arr2[:]...) // want `variadic argument "args".+ but has 3 elements`
fnSlice("", []interface{}{1, 2, 3}) // want `argument "args".+ but has 3 elements`
fnSlice("", []interface{}{1, 2, 3, 4})
fnIndirect("%s", 1, 2, 3) // want `argument "args".+ but has 3 elements`
fnIndirect("%s", 1, 2)
strings.NewReplacer("one") // want `variadic argument "oldnew".+ but has 1 elements`
strings.NewReplacer("one", "two")
}
func fn3() {
args := []interface{}{""}
if true {
fnSlice("", args) // want `but has 1 element`
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckExec/ 0000775 0000000 0000000 00000000000 14143223131 0022203 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckExec/CheckExec.go 0000664 0000000 0000000 00000000377 14143223131 0024363 0 ustar 00root root 0000000 0000000 package pkg
import "os/exec"
func fn() {
exec.Command("ls")
exec.Command("ls arg1") // want `first argument to exec`
exec.Command(`C:\Program Files\this\is\insane.exe`)
exec.Command("/Library/Application Support/VMware Tools/vmware-tools-daemon")
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckExtremeComparison/ 0000775 0000000 0000000 00000000000 14143223131 0024763 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckExtremeComparison/CheckExtremeComparison.go 0000664 0000000 0000000 00000002545 14143223131 0031722 0 ustar 00root root 0000000 0000000 package pkg
import "math"
func fn1() {
var (
u8 uint8
u16 uint16
u uint
i8 int8
i16 int16
i int
)
_ = u8 > math.MaxUint8 // want `no value of type uint8 is greater than math\.MaxUint8`
_ = u8 >= math.MaxUint8 // want `no value of type uint8 is greater than math\.MaxUint8`
_ = u8 >= 0 // want `every value of type uint8 is >= 0`
_ = u8 <= math.MaxUint8 // want `every value of type uint8 is <= math\.MaxUint8`
_ = u8 > 0
_ = u8 >= 1
_ = u8 < math.MaxUint8
_ = u8 < 0 // want `no value of type uint8 is less than 0`
_ = u8 <= 0
_ = 0 > u8 // want `no value of type uint8 is less than 0`
_ = 0 >= u8
_ = u16 > math.MaxUint8
_ = u16 > math.MaxUint16 // want `no value of type uint16 is greater than math\.MaxUint16`
_ = u16 <= math.MaxUint8
_ = u16 <= math.MaxUint16 // want `every value of type uint16 is <= math\.MaxUint16`
_ = u > math.MaxUint32
_ = i8 > math.MaxInt8 // want `no value of type int8 is greater than math\.MaxInt8`
_ = i16 > math.MaxInt8
_ = i16 > math.MaxInt16 // want `no value of type int16 is greater than math\.MaxInt16`
_ = i > math.MaxInt32
_ = i8 < 0
_ = i8 <= math.MinInt8 // want `no value of type int8 is less than math\.MinInt8`
_ = i8 < math.MinInt8 // want `no value of type int8 is less than math\.MinInt8`
_ = i8 >= math.MinInt8 // want `every value of type int8 is >= math.MinInt8`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckExtremeComparison/CheckExtremeComparison64.go 0000664 0000000 0000000 00000000510 14143223131 0032062 0 ustar 00root root 0000000 0000000 // +build amd64 arm64 ppc64 ppc64le mips64 mips64le mips64p32 mips64p32le sparc64
package pkg
import "math"
func fn2() {
var (
u uint
i int
)
_ = u > math.MaxUint64 // want `no value of type uint is greater than math\.MaxUint64`
_ = i > math.MaxInt64 // want `no value of type int is greater than math\.MaxInt64`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckImpossibleTypeAssertion/ 0000775 0000000 0000000 00000000000 14143223131 0026157 5 ustar 00root root 0000000 0000000 CheckImpossibleTypeAssertion.go 0000664 0000000 0000000 00000001002 14143223131 0034216 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckImpossibleTypeAssertion package pkg
import "fmt"
type i1 interface {
String() int
}
type i2 interface {
String() string
}
type i3 interface {
bar() int
}
type i4 interface {
String() int
bar() int
}
func fn() {
var v1 i1
_ = v1.(i2) // want `impossible type assertion; i1 and i2 contradict each other`
_ = v1.(i3)
_ = v1.(i4)
_ = v1.(fmt.Stringer) // want `impossible type assertion; i1 and fmt.Stringer contradict each other`
_ = v1.(interface { // want `i1 and.+String.+contradict each other`
String() string
})
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckIneffectiveAppend/ 0000775 0000000 0000000 00000000000 14143223131 0024676 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckIneffectiveAppend/CheckIneffectiveAppend.go 0000664 0000000 0000000 00000006063 14143223131 0031547 0 ustar 00root root 0000000 0000000 package pkg
import "fmt"
func fn1() {
var s []int
s = append(s, 1) // want `this result of append is never used`
s = append(s, 1) // want `this result of append is never used`
}
func fn2() (named []int) {
named = append(named, 1)
return
}
func fn3() {
s := make([]int, 0)
s = append(s, 1) // want `this result of append is never used`
}
func fn3_1(n int) {
s := make([]int, n)
s = append(s, 1) // want `this result of append is never used`
}
func fn4() []int {
var s []int
s = append(s, 1)
return s
}
func fn5() {
var s []int
s = append(s, 1)
fn6(s)
}
func fn6([]int) {}
func fn7() {
var s []int
fn8(&s)
s = append(s, 1)
}
func fn8(*[]int) {}
func fn9() {
var s []int
s = append(s, 1)
fmt.Println(s)
s = append(s, 1)
}
func fn10() {
var s []int
return
s = append(s, 1)
}
func fn11() {
var s []int
for x := 0; x < 10; x++ {
s = append(s, 1) // want `this result of append is never used`
}
}
func fn12(a []int) {
b := a[:0]
for _, x := range a {
if true {
b = append(b, x)
}
}
}
func fn13() []byte {
a := make([]byte, 10)
b := a[:5]
for i := 0; i < 2; i++ {
a = append(a, 1)
}
return b
}
func fn14() []byte {
a := make([]byte, 10)
b := a[:5]
for i := 0; i < 2; i++ {
b = append(b, 1)
}
return a
}
func fn15() {
s := make([]byte, 0, 1)
retain(s)
s = append(s, 1)
}
func fn16(s []byte) {
for i := 0; i < 2; i++ {
s = append(s, 1)
}
}
func fn17(x *[5]byte) {
s := x[:0]
for i := 0; i < 2; i++ {
s = append(s, 1)
}
}
func fn18() {
var x [4]byte
s := x[:0]
for i := 0; i < 2; i++ {
s = append(s, 1)
}
_ = x
}
func fn19() [4]int {
var x [4]int
s := x[:]
s = append(s, 1)
return x
}
func fn20() {
var x [4]int
s := x[:]
s = append(s, 1) // want `this result of append is never used`
}
func fn21() {
var x []byte
x = append(x, 1)
retain(x)
x = append(x, 2)
}
func fn22() {
// we should probably flag this, but we currently don't
var x1 []byte
x2 := append(x1, 1)
x2 = append(x2, 2)
x3 := append(x1, 3)
x3 = append(x3, 4)
}
func fn23(n int) []int {
s := make([]int, 0, n)
s2 := append(s, 1, 2, 3) // this can be observed by extending the capacity of x
s2 = append(s2, 4)
x := append(s, 2)
return x
}
func fn24() []byte {
x := make([]byte, 0, 24)
s1 := append(x, 1)
s2 := append(s1, 2)
s2 = append(s2, 3)
s3 := append(s1, 4)
return s3
}
func fn25() {
var s []byte
if true {
s = append(s, 1)
}
s = append(s, 2) // want `this result of append is never used`
}
func fn26() {
var s []byte
if true {
s = append(s, 1)
retain(s)
}
s = append(s, 2)
}
func fn27() {
var s []byte
if true {
s = make([]byte, 0, 1)
} else {
s = make([]byte, 0, 2)
}
s = append(s, 1) // want `this result of append is never used`
}
func fn28() {
var s []byte
if true {
s = make([]byte, 0, 1)
} else {
s = make([]byte, 0, 2)
retain(s)
}
s = append(s, 1)
}
func fn29() {
x := gen()
x = append(x, 1)
}
func fn30(x T) {
s := x.s
s = append(s, 1)
}
var Global []int
func fn31() {
Global = append(Global, 1)
}
type T struct {
s []byte
}
func gen() []byte { return nil }
func retain([]byte) {}
go-tools-2021.1.2/staticcheck/testdata/src/CheckIneffectiveCopy/ 0000775 0000000 0000000 00000000000 14143223131 0024401 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckIneffectiveCopy/CheckIneffectiveCopy.go 0000664 0000000 0000000 00000000304 14143223131 0030745 0 ustar 00root root 0000000 0000000 package pkg
type T struct{}
func fn1(_ *T) {}
func fn2() {
t1 := &T{}
fn1(&*t1) // want `will not copy`
fn1(*&t1) // want `will not copy`
_Cvar_something := &T{}
fn1(&*_Cvar_something)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckIneffectiveFieldAssignments/ 0000775 0000000 0000000 00000000000 14143223131 0026726 5 ustar 00root root 0000000 0000000 CheckIneffectiveFieldAssignments.go 0000664 0000000 0000000 00000003041 14143223131 0035541 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckIneffectiveFieldAssignments package pkg
type T1 struct {
T2 // make sure embedded fields don't throw off our numbering
x int
y int
z T2
}
type T2 struct {
x int
y int
z int
}
type T3 struct {
T2
}
func (v T1) fn1() {
v.x = 1
v.y = 1 // want `ineffective assignment to field T1.y`
println(v.x)
}
func (v T1) fn2() {
println(v.x)
v.x = 1 // want `ineffective assignment to field T1.x`
}
func (v T1) fn3() {
if true {
println(v.x)
}
v.x = 1 // want `ineffective assignment to field T1.x`
}
func (v T1) fn10() {
v.x = 1
if true {
println(v.x)
}
}
func (v T1) fn4() {
v.x = 1
v.dump()
}
func (v T1) fn5() {
v.dump()
v.x = 1 // want `ineffective assignment to field T1.x`
}
func (v T1) fn6() {
v.x = 1
v.y = 1
println(v.y)
println(v.x)
}
func (v T1) fn7() {
// not currently being flagged because it's a nested field
v.z.x = 1
}
func (v T1) fn8() {
v.x++ // want `ineffective assignment to field T1.x`
}
func (v T1) fn9() {
v.x++
println(v.x)
}
func (v T1) fn11() {
v = T1{x: 42, y: 23} // not currently being flagged
}
func (v T1) fn12() {
v = T1{x: 42, y: 23} // not currently being flagged
println(v.y)
}
func (v T1) fn13() {
v = T1{x: 42}
v.y = 23 // not currently being flagged, we gave up when we saw the assignment to v
println(v.x)
}
func (v T1) fn14() {
v = T1{x: 42} // not currently being flagged
v.y = 23
println(v.y)
}
func (v T1) fn15() {
// not currently being flagged
v = T1{x: 42}
}
func (v T1) dump() {}
func (v T3) fn1() {
// not currently being flagged because it's a nested field (via
// embedding)
v.x = 1
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckIneffectiveFieldAssignments/issue141.go 0000664 0000000 0000000 00000000641 14143223131 0030634 0 ustar 00root root 0000000 0000000 package pkg
import "fmt"
// T is t
type T struct {
X bool
F string
}
// Modify modifies T.F to say modified, then calls EchoF.
func (t T) Modify() {
if t.X {
t.X, t.F = true, "modified"
}
t.EchoF()
}
// EchoF prints F.
func (t T) EchoF() {
fmt.Println(t.F)
}
func main() {
t := T{X: true, F: "original"}
t.EchoF() // output: original
t.Modify() // output: modified
t.EchoF() // output: original
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckIneffectiveLoop/ 0000775 0000000 0000000 00000000000 14143223131 0024400 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckIneffectiveLoop/CheckIneffectiveLoop.go 0000664 0000000 0000000 00000001231 14143223131 0030743 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
for {
if true {
println()
}
break // want `the surrounding loop is unconditionally terminated`
}
for {
if true {
break
} else {
break
}
}
for range ([]int)(nil) {
if true {
println()
}
break // want `the surrounding loop is unconditionally terminated`
}
for range (map[int]int)(nil) {
if true {
println()
}
break
}
for {
if true {
goto Label
}
break
Label:
}
for {
if true {
continue
}
break
}
for {
if true {
continue
}
break
}
}
var z = func() {
for {
if true {
println()
}
break // want `the surrounding loop is unconditionally terminated`
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckIneffectiveURLQueryModification/ 0000775 0000000 0000000 00000000000 14143223131 0027505 5 ustar 00root root 0000000 0000000 CheckIneffectiveURLQueryModification.go 0000664 0000000 0000000 00000000542 14143223131 0037102 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckIneffectiveURLQueryModification package pkg
import "net/url"
func fn(u *url.URL) {
u.Query().Add("", "") // want `returns a copy`
u.Query().Set("", "") // want `returns a copy`
u.Query().Del("") // want `returns a copy`
u.Query().Encode()
var t T
t.Query().Add("", "")
}
type T struct{}
func (v T) Query() T { return v }
func (v T) Add(arg1, arg2 string) {}
go-tools-2021.1.2/staticcheck/testdata/src/CheckInfiniteEmptyLoop/ 0000775 0000000 0000000 00000000000 14143223131 0024735 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckInfiniteEmptyLoop/CheckInfiniteEmptyLoop.go 0000664 0000000 0000000 00000000755 14143223131 0031647 0 ustar 00root root 0000000 0000000 package pkg
func fn2() bool { return true }
func fn() {
for { // want `this loop will spin`
}
for fn2() {
}
for {
break
}
for true { // want `loop condition never changes` `this loop will spin`
}
x := true
for x { // want `loop condition never changes` `this loop will spin`
}
x = false
for x { // want `loop condition never changes` `this loop will spin`
}
for false {
}
false := true
for false { // want `loop condition never changes` `this loop will spin`
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckInfiniteRecursion/ 0000775 0000000 0000000 00000000000 14143223131 0024756 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckInfiniteRecursion/CheckInfiniteRecursion.go 0000664 0000000 0000000 00000001462 14143223131 0031705 0 ustar 00root root 0000000 0000000 package pkg
func fn1(x int) bool {
println(x)
return fn1(x + 1) // want `infinite recursive call`
return true
}
func fn2(x int) bool {
println(x)
if x > 10 {
return true
}
return fn2(x + 1)
}
func fn3(x int) bool {
println(x)
if x > 10 {
goto l1
}
return fn3(x + 1)
l1:
println(x)
return true
}
func fn4(p *int, n int) {
if n == 0 {
return
}
x := 0
fn4(&x, n-1)
if x != n {
panic("stack is corrupted")
}
}
func fn5(p *int, n int) {
x := 0
fn5(&x, n-1) // want `infinite recursive call`
if x != n {
panic("stack is corrupted")
}
}
func fn6() {
go fn6()
}
type T struct {
n int
}
func (t T) Fn1() {
t.Fn1() // want `infinite recursive call`
}
func (t T) Fn2() {
x := T{}
x.Fn2() // want `infinite recursive call`
}
func (t T) Fn3() {
if t.n == 0 {
return
}
t.Fn1()
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckIntegerDivisionEqualsZero/ 0000775 0000000 0000000 00000000000 14143223131 0026434 5 ustar 00root root 0000000 0000000 CheckIntegerDivisionEqualsZero.go 0000664 0000000 0000000 00000000571 14143223131 0034762 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckIntegerDivisionEqualsZero package pkg
func foo(x float64) {}
func fn() {
_ = 2 / 3 // want `results in zero`
_ = 4 / 2
_ = 4 / 3
_ = 0 / 2 // want `results in zero`
_ = 2 / 3.
_ = 2 / 3.0
_ = 2.0 / 3
const _ = 2 / 3 // want `results in zero`
const _ float64 = 2 / 3 // want `results in zero`
_ = float64(2 / 3) // want `results in zero`
foo(1 / 2) // want `results in zero`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckLeakyTimeTick-main/ 0000775 0000000 0000000 00000000000 14143223131 0024740 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckLeakyTimeTick-main/CheckLeakyTimeTick-main.go 0000664 0000000 0000000 00000000223 14143223131 0031643 0 ustar 00root root 0000000 0000000 package main
import "time"
func fn2() {
for range time.Tick(0) {
println("")
if true {
break
}
}
}
func main() {
_ = time.Tick(0)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckLeakyTimeTick/ 0000775 0000000 0000000 00000000000 14143223131 0024016 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckLeakyTimeTick/CheckLeakyTimeTick.go 0000664 0000000 0000000 00000001211 14143223131 0027775 0 ustar 00root root 0000000 0000000 package pkg
import "time"
func fn1() {
for range time.Tick(0) {
println("")
}
}
func fn2() {
for range time.Tick(0) { // want `leaks the underlying ticker`
println("")
if true {
break
}
}
}
func fn3() {
for range time.Tick(0) { // want `leaks the underlying ticker`
println("")
if true {
return
}
}
}
func fn4() {
go func() {
for range time.Tick(0) {
println("")
}
}()
}
func fn5() {
if false {
panic("foo")
}
for range time.Tick(0) {
println("")
}
}
type T struct{}
func (t *T) foo() {
for range time.Tick(0) {
println("")
}
}
func (t T) bar() {
for range time.Tick(0) {
println("")
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckLhsRhsIdentical/ 0000775 0000000 0000000 00000000000 14143223131 0024337 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckLhsRhsIdentical/CheckLhsRhsIdentical.go 0000664 0000000 0000000 00000003717 14143223131 0030654 0 ustar 00root root 0000000 0000000 package pkg
import "math/rand"
type Float float64
type Floats [5]float64
type Ints [5]int
type T1 struct {
A float64
B float64
}
type T2 struct {
A float64
B int
}
func fn(a int, s []int, f1 float64, f2 Float, fs Floats, is Ints, t1 T1, t2 T2) {
if 0 == 0 { // want `identical expressions`
println()
}
if 1 == 1 { // want `identical expressions`
println()
}
if a == a { // want `identical expressions`
println()
}
if a != a { // want `identical expressions`
println()
}
if s[0] == s[0] { // want `identical expressions`
println()
}
if 1&1 == 1 { // want `identical expressions`
println()
}
if (1 + 2 + 3) == (1 + 2 + 3) { // want `identical expressions`
println()
}
if f1 == f1 {
println()
}
if f1 != f1 {
println()
}
if f1 > f1 {
println()
}
if f1-f1 == 0 {
println()
}
if f2 == f2 {
println()
}
if fs == fs {
println()
}
if is == is { // want `identical expressions`
println()
}
if t1 == t1 {
println()
}
if t2 == t2 { // want `identical expressions`
println()
}
}
func fn2() {
_ = rand.Int() - rand.Int()
_ = rand.Int31() - rand.Int31()
_ = rand.Int31n(0) - rand.Int31n(0)
_ = rand.Int63() - rand.Int63()
_ = rand.Int63n(0) - rand.Int63n(0)
_ = rand.Intn(0) - rand.Intn(0)
_ = rand.Uint32() - rand.Uint32()
_ = rand.Uint64() - rand.Uint64()
_ = rand.ExpFloat64() - rand.ExpFloat64()
_ = rand.Float32() - rand.Float32()
_ = rand.Float64() - rand.Float64()
_ = rand.NormFloat64() - rand.NormFloat64()
var rng *rand.Rand
_ = rng.Int() - rng.Int()
_ = rng.Int31() - rng.Int31()
_ = rng.Int31n(0) - rng.Int31n(0)
_ = rng.Int63() - rng.Int63()
_ = rng.Int63n(0) - rng.Int63n(0)
_ = rng.Intn(0) - rng.Intn(0)
_ = rng.Uint32() - rng.Uint32()
_ = rng.Uint64() - rng.Uint64()
_ = rng.ExpFloat64() - rng.ExpFloat64()
_ = rng.Float32() - rng.Float32()
_ = rng.Float64() - rng.Float64()
_ = rng.NormFloat64() - rng.NormFloat64()
_ = rand.NewSource(0) == rand.NewSource(0) // want `identical expressions`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckLhsRhsIdentical/cgo.go 0000664 0000000 0000000 00000000360 14143223131 0025435 0 ustar 00root root 0000000 0000000 package pkg
// void foo(void **p) {}
import "C"
import "unsafe"
func Foo() {
var p unsafe.Pointer
C.foo(&p)
if 0 == 0 {
// We don't currently flag this instance of 0 == 0 because of
// our cgo-specific exception.
println()
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckListenAddress/ 0000775 0000000 0000000 00000000000 14143223131 0024063 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckListenAddress/CheckListenAddress.go 0000664 0000000 0000000 00000000735 14143223131 0030121 0 ustar 00root root 0000000 0000000 package pkg
import "net/http"
func fn() {
// Seen in actual code
http.ListenAndServe("localhost:8080/", nil) // want `invalid port or service name in host:port pair`
http.ListenAndServe("localhost", nil) // want `invalid port or service name in host:port pair`
http.ListenAndServe("localhost:8080", nil)
http.ListenAndServe(":8080", nil)
http.ListenAndServe(":http", nil)
http.ListenAndServe("localhost:http", nil)
http.ListenAndServe("local_host:8080", nil)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckLoopCondition/ 0000775 0000000 0000000 00000000000 14143223131 0024077 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckLoopCondition/CheckLoopCondition.go 0000664 0000000 0000000 00000000362 14143223131 0030145 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
for i := 0; i < 10; i++ {
for j := 0; j < 10; i++ { // want `variable in loop condition never changes`
}
}
counter := 0
for i := 0; i < 10; i++ {
for j := 0; j < 10; counter++ {
x := &j
*x++
}
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckLoopEmptyDefault/ 0000775 0000000 0000000 00000000000 14143223131 0024554 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckLoopEmptyDefault/CheckLoopEmptyDefault.go 0000664 0000000 0000000 00000000434 14143223131 0031277 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var ch chan int
select {
case <-ch:
default:
}
for {
select {
case <-ch:
default: // want `should not have an empty default case`
}
}
for {
select {
case <-ch:
default:
println("foo")
}
}
for {
select {
case <-ch:
}
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckLoopEmptyDefault/CheckLoopEmptyDefault.go.golden 0000664 0000000 0000000 00000000424 14143223131 0032545 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var ch chan int
select {
case <-ch:
default:
}
for {
select {
case <-ch:
// want `should not have an empty default case`
}
}
for {
select {
case <-ch:
default:
println("foo")
}
}
for {
select {
case <-ch:
}
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckMapBytesKey/ 0000775 0000000 0000000 00000000000 14143223131 0023514 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckMapBytesKey/key.go 0000664 0000000 0000000 00000000424 14143223131 0024633 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var m map[string]int
var b []byte
_ = m[string(b)]
_ = m[string(b)]
s1 := string(b) // want `m\[string\(key\)\] would be more efficient than k := string\(key\); m\[k\]`
_ = m[s1]
_ = m[s1]
s2 := string(b)
_ = m[s2]
_ = m[s2]
println(s2)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckMathInt/ 0000775 0000000 0000000 00000000000 14143223131 0022663 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckMathInt/CheckMathInt.go 0000664 0000000 0000000 00000000303 14143223131 0025510 0 ustar 00root root 0000000 0000000 package pkg
import "math"
func fn(x int) {
math.Ceil(float64(x)) // want `on a converted integer is pointless`
math.Floor(float64(x * 2)) // want `on a converted integer is pointless`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckMaybeNil/ 0000775 0000000 0000000 00000000000 14143223131 0023017 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckMaybeNil/CheckMaybeNil.go 0000664 0000000 0000000 00000004201 14143223131 0026001 0 ustar 00root root 0000000 0000000 package pkg
import (
"os"
"syscall"
)
func fn1(x *int) {
_ = *x // want `possible nil pointer dereference`
if x != nil {
return
}
println()
}
func fn1_1(x *int) {
// this doesn't get flagged because the conditional return gets optimized away
_ = *x
if x != nil {
return
}
}
func fn2(x *int) {
if x == nil {
println("we should return")
}
_ = *x // want `possible nil pointer dereference`
}
func fn3(x *int) {
if x != nil {
_ = *x
}
}
func fn4(x *int) {
if x == nil {
x = gen()
}
_ = *x
}
func fn5(x *int) {
if x == nil {
x = gen()
}
_ = *x // want `possible nil pointer dereference`
if x == nil {
println("we should return")
}
}
func fn6() {
x := new(int)
if x == nil {
println("we should return")
}
// x can't be nil
_ = *x
}
func fn7() {
var x int
y := &x
if y == nil {
println("we should return")
}
// y can't be nil
_ = *y
}
func fn8(x *int) {
if x == nil {
return
}
// x can't be nil
_ = *x
}
func fn9(x *int) {
if x != nil {
return
}
// TODO(dh): not currently supported
_ = *x
}
func gen() *int { return nil }
func die1(b bool) {
if b {
println("yay")
os.Exit(0)
} else {
println("nay")
os.Exit(1)
}
}
func die2(b bool) {
if b {
println("yay")
os.Exit(0)
}
}
func fn10(x *int) {
if x == nil {
die1(true)
}
_ = *x
}
func fn11(x *int) {
if x == nil {
die2(true)
}
_ = *x // want `possible nil pointer dereference`
}
func doPanic() { panic("") }
func doExit() { syscall.Exit(1) }
func fn12(arg bool) {
if arg {
doPanic()
} else {
doExit()
}
}
func fn13(arg bool) {
fn12(arg)
}
func fn14(x *int) {
if x == nil {
fn13(true)
}
_ = *x
}
func assert(b bool) {
if b {
panic("meh")
}
}
func fn15(x *int) {
assert(x != nil)
_ = *x
}
func fn16() {
var xs []int
if xs == nil {
println()
}
for _, x := range xs {
_ = x
}
var xs2 *[1]int
if xs2 == nil {
println()
}
for _, x := range xs2 { // want `possible nil pointer dereference`
_ = x
}
var xs3 *[]int
if xs3 == nil {
println()
}
for _, x := range *xs3 { // want `possible nil pointer dereference`
_ = x
}
var xs4 []int
if xs4 == nil {
println()
}
_ = xs4[0]
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckMissingEnumTypesInDeclaration/ 0000775 0000000 0000000 00000000000 14143223131 0027237 5 ustar 00root root 0000000 0000000 CheckMissingEnumTypesInDeclaration.go 0000664 0000000 0000000 00000002302 14143223131 0036362 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckMissingEnumTypesInDeclaration package pkg
const c1 int = 0
const c2 = 0
const (
c3 int = iota
c4
c5
)
const (
c6 int = 1 // want `only the first constant in this group has an explicit type`
c7 = 2 // comment for testing https://github.com/dominikh/go-tools/issues/866
c8 = 3
)
const (
c9 int = 1
c10 = 2
c11 = 3
c12 int = 4
)
const (
c13 = 1
c14 int = 2
c15 int = 3
c16 int = 4
)
const (
c17 = 1
c18 int = 2
c19 = 3
c20 int = 4
)
const (
c21 int = 1
c22 = 2
)
const (
c23 int = 1
c24 int = 2
c25 string = "" // want `only the first constant in this group has an explicit type`
c26 = ""
c27 = 1
c28 int = 2
c29 int = 1
c30 = 2
c31 int = 2
c32 string = "" // want `only the first constant in this group has an explicit type`
c33 = ""
)
const (
c34 int = 1 // want `only the first constant in this group has an explicit type`
c35 = 2
c36 int = 2
)
const (
c37 int = 1
c38 = "2"
)
const (
c39 int8 = 1.0 // want `only the first constant in this group has an explicit type`
c40 = 'a'
c41 = 3
)
type String string
const (
c42 String = "" // want `only the first constant in this group has an explicit type`
c43 = ""
)
CheckMissingEnumTypesInDeclaration.go.golden 0000664 0000000 0000000 00000002302 14143223131 0037631 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckMissingEnumTypesInDeclaration package pkg
const c1 int = 0
const c2 = 0
const (
c3 int = iota
c4
c5
)
const (
c6 int = 1 // want `only the first constant in this group has an explicit type`
c7 int = 2 // comment for testing https://github.com/dominikh/go-tools/issues/866
c8 int = 3
)
const (
c9 int = 1
c10 = 2
c11 = 3
c12 int = 4
)
const (
c13 = 1
c14 int = 2
c15 int = 3
c16 int = 4
)
const (
c17 = 1
c18 int = 2
c19 = 3
c20 int = 4
)
const (
c21 int = 1
c22 = 2
)
const (
c23 int = 1
c24 int = 2
c25 string = "" // want `only the first constant in this group has an explicit type`
c26 string = ""
c27 = 1
c28 int = 2
c29 int = 1
c30 = 2
c31 int = 2
c32 string = "" // want `only the first constant in this group has an explicit type`
c33 string = ""
)
const (
c34 int = 1 // want `only the first constant in this group has an explicit type`
c35 int = 2
c36 int = 2
)
const (
c37 int = 1
c38 = "2"
)
const (
c39 int8 = 1.0 // want `only the first constant in this group has an explicit type`
c40 int8 = 'a'
c41 int8 = 3
)
type String string
const (
c42 String = "" // want `only the first constant in this group has an explicit type`
c43 String = ""
)
go-tools-2021.1.2/staticcheck/testdata/src/CheckNaNComparison/ 0000775 0000000 0000000 00000000000 14143223131 0024026 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckNaNComparison/CheckNaNComparison.go 0000664 0000000 0000000 00000000510 14143223131 0030016 0 ustar 00root root 0000000 0000000 package pkg
import "math"
func fn(f float64) {
_ = f == math.NaN() // want `no value is equal to NaN`
_ = f > math.NaN() // want `no value is equal to NaN`
_ = f != math.NaN() // want `no value is equal to NaN`
}
func fn2(f float64) {
x := math.NaN()
if true {
if f == x { // want `no value is equal to NaN`
}
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckNegativeZeroFloat/ 0000775 0000000 0000000 00000000000 14143223131 0024707 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckNegativeZeroFloat/CheckNegativeZeroFloat.go 0000664 0000000 0000000 00000002067 14143223131 0031571 0 ustar 00root root 0000000 0000000 package pkg
const x = 0.0
func fn() {
_ = -0.0 // want `in Go, the floating-point literal '-0\.0' is the same as '0\.0', it does not produce a negative zero`
_ = float32(-0.0) // want `in Go, the floating-point literal '-0\.0' is the same as '0\.0', it does not produce a negative zero`
_ = float64(-0.0) // want `in Go, the floating-point literal '-0\.0' is the same as '0\.0', it does not produce a negative zero`
_ = -float32(0) // want `in Go, the floating-point expression '-float32\(0\)' is the same as 'float32\(0\)', it does not produce a negative zero`
_ = -float64(0) // want `in Go, the floating-point expression '-float64\(0\)' is the same as 'float64\(0\)', it does not produce a negative zero`
_ = -float32(0.0) // want `in Go, the floating-point expression '-float32\(0\.0\)' is the same as 'float32\(0\.0\)', it does not produce a negative zero`
_ = -float64(0.0) // want `in Go, the floating-point expression '-float64\(0\.0\)' is the same as 'float64\(0\.0\)', it does not produce a negative zero`
// intentionally not flagged
_ = -x
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckNegativeZeroFloat/CheckNegativeZeroFloat.go.golden 0000664 0000000 0000000 00000002247 14143223131 0033040 0 ustar 00root root 0000000 0000000 package pkg
const x = 0.0
func fn() {
_ = math.Copysign(0, -1) // want `in Go, the floating-point literal '-0\.0' is the same as '0\.0', it does not produce a negative zero`
_ = float32(math.Copysign(0, -1)) // want `in Go, the floating-point literal '-0\.0' is the same as '0\.0', it does not produce a negative zero`
_ = float64(math.Copysign(0, -1)) // want `in Go, the floating-point literal '-0\.0' is the same as '0\.0', it does not produce a negative zero`
_ = float32(math.Copysign(0, -1)) // want `in Go, the floating-point expression '-float32\(0\)' is the same as 'float32\(0\)', it does not produce a negative zero`
_ = math.Copysign(0, -1) // want `in Go, the floating-point expression '-float64\(0\)' is the same as 'float64\(0\)', it does not produce a negative zero`
_ = float32(math.Copysign(0, -1)) // want `in Go, the floating-point expression '-float32\(0\.0\)' is the same as 'float32\(0\.0\)', it does not produce a negative zero`
_ = math.Copysign(0, -1) // want `in Go, the floating-point expression '-float64\(0\.0\)' is the same as 'float64\(0\.0\)', it does not produce a negative zero`
// intentionally not flagged
_ = -x
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckNilMaps/ 0000775 0000000 0000000 00000000000 14143223131 0022662 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckNilMaps/CheckNilMaps.go 0000664 0000000 0000000 00000000564 14143223131 0025517 0 ustar 00root root 0000000 0000000 package pkg
import "fmt"
func fn1() {
var m map[int]int
m[1] = 1 // want `assignment to nil map`
}
func fn2(m map[int]int) {
m[1] = 1
}
func fn3() {
v := []int{1, 2, 3}
var m map[string]int
for i := range v {
m["a"] = i // want `assignment to nil map`
}
fmt.Println(m["a"])
}
func fn4() {
m := map[string]int{}
if true {
if true {
m[""] = 0
}
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckNonOctalFileMode/ 0000775 0000000 0000000 00000000000 14143223131 0024441 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckNonOctalFileMode/CheckNonOctalFileMode.go 0000664 0000000 0000000 00000000267 14143223131 0031055 0 ustar 00root root 0000000 0000000 package pkg
import "os"
func fn() {
os.OpenFile("", 0, 644) // want `file mode.+`
}
func fn2() (string, int, os.FileMode) {
return "", 0, 0
}
func fn3() {
os.OpenFile(fn2())
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckNonOctalFileMode/CheckNonOctalFileMode.go.golden 0000664 0000000 0000000 00000000270 14143223131 0032316 0 ustar 00root root 0000000 0000000 package pkg
import "os"
func fn() {
os.OpenFile("", 0, 0644) // want `file mode.+`
}
func fn2() (string, int, os.FileMode) {
return "", 0, 0
}
func fn3() {
os.OpenFile(fn2())
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckNonUniqueCutset/ 0000775 0000000 0000000 00000000000 14143223131 0024430 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckNonUniqueCutset/CheckNonUniqueCutset.go 0000664 0000000 0000000 00000000362 14143223131 0031027 0 ustar 00root root 0000000 0000000 package pkg
import "strings"
func fn(s string) {
_ = strings.TrimLeft(s, "")
_ = strings.TrimLeft(s, "a")
_ = strings.TrimLeft(s, "Β΅")
_ = strings.TrimLeft(s, "abc")
_ = strings.TrimLeft(s, "http://") // want `duplicate characters`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckNoopMarshal/ 0000775 0000000 0000000 00000000000 14143223131 0023542 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckNoopMarshal/CheckNoopMarshal.go 0000664 0000000 0000000 00000011012 14143223131 0027245 0 ustar 00root root 0000000 0000000 package pkg
import (
"encoding/json"
"encoding/xml"
)
type T1 struct{}
type T2 struct{ x int }
type T3 struct{ X int }
type T4 struct{ T3 }
type t5 struct{ X int }
type T6 struct{ t5 }
type T7 struct{ x int }
func (T7) MarshalJSON() ([]byte, error) { return nil, nil }
func (*T7) UnmarshalJSON([]byte) error { return nil }
type T8 struct{ x int }
func (T8) MarshalXML() ([]byte, error) { return nil, nil }
func (*T8) UnmarshalXML(*xml.Decoder, *xml.StartElement) error { return nil }
type T9 struct{}
func (T9) MarshalText() ([]byte, error) { return nil, nil }
func (*T9) UnmarshalText([]byte) error { return nil }
type T10 struct{}
type T11 struct{ T10 }
type T12 struct{ T7 }
type t13 struct{}
func (t13) MarshalJSON() ([]byte, error) { return nil, nil }
type T14 struct{ t13 }
type T15 struct{ *t13 }
type T16 struct{ *T3 }
type T17 struct{ *T17 }
type T18 struct {
T17
Actual int
}
func fn() {
// don't flag structs with no fields
json.Marshal(T1{})
// no exported fields
json.Marshal(T2{}) // want `struct type 'CheckNoopMarshal.T2' doesn't have any exported fields, nor custom marshaling`
// pointer vs non-pointer makes no difference
json.Marshal(&T2{}) // want `struct type 'CheckNoopMarshal.T2' doesn't have any exported fields, nor custom marshaling`
// exported field
json.Marshal(T3{})
// exported field, pointer makes no difference
json.Marshal(&T3{})
// embeds struct with exported fields
json.Marshal(T4{})
// exported field
json.Marshal(t5{})
// embeds unexported type, but said type does have exported fields
json.Marshal(T6{})
// MarshalJSON
json.Marshal(T7{})
// MarshalXML does not apply to JSON
json.Marshal(T8{}) // want `struct type 'CheckNoopMarshal.T8' doesn't have any exported fields, nor custom marshaling`
// MarshalText
json.Marshal(T9{})
// embeds exported struct, but it has no fields
json.Marshal(T11{}) // want `struct type 'CheckNoopMarshal.T11' doesn't have any exported fields, nor custom marshaling`
// embeds type with MarshalJSON
json.Marshal(T12{})
// embeds type with MarshalJSON and type isn't exported
json.Marshal(T14{})
// embedded pointer with MarshalJSON
json.Marshal(T15{})
// embedded pointer to struct with exported fields
json.Marshal(T16{})
// don't recurse forever on recursive data structure
json.Marshal(T17{}) // want `struct type 'CheckNoopMarshal.T17' doesn't have any exported fields, nor custom marshaling`
json.Marshal(T18{})
// MarshalJSON does not apply to JSON
xml.Marshal(T7{}) // want `struct type 'CheckNoopMarshal.T7' doesn't have any exported fields, nor custom marshaling`
// MarshalXML
xml.Marshal(T8{})
var t2 T2
var t3 T3
var t7 T7
var t8 T8
var t9 T9
// check that all other variations of methods also work
json.Unmarshal(nil, &t2) // want `struct type 'CheckNoopMarshal.T2' doesn't have any exported fields, nor custom marshaling`
json.Unmarshal(nil, &t3)
json.Unmarshal(nil, &t9)
xml.Unmarshal(nil, &t2) // want `struct type 'CheckNoopMarshal.T2' doesn't have any exported fields, nor custom marshaling`
xml.Unmarshal(nil, &t3)
xml.Unmarshal(nil, &t9)
(*json.Decoder)(nil).Decode(&t2) // want `struct type 'CheckNoopMarshal.T2' doesn't have any exported fields, nor custom marshaling`
(*json.Decoder)(nil).Decode(&t3)
(*json.Decoder)(nil).Decode(&t9)
(*json.Encoder)(nil).Encode(t2) // want `struct type 'CheckNoopMarshal.T2' doesn't have any exported fields, nor custom marshaling`
(*json.Encoder)(nil).Encode(t3)
(*json.Encoder)(nil).Encode(t9)
(*xml.Decoder)(nil).Decode(&t2) // want `struct type 'CheckNoopMarshal.T2' doesn't have any exported fields, nor custom marshaling`
(*xml.Decoder)(nil).Decode(&t3)
(*xml.Decoder)(nil).Decode(&t9)
(*xml.Encoder)(nil).Encode(t2) // want `struct type 'CheckNoopMarshal.T2' doesn't have any exported fields, nor custom marshaling`
(*xml.Encoder)(nil).Encode(t3)
(*xml.Encoder)(nil).Encode(t9)
(*json.Decoder)(nil).Decode(&t7)
(*json.Decoder)(nil).Decode(&t8) // want `struct type 'CheckNoopMarshal.T8' doesn't have any exported fields, nor custom marshaling`
(*json.Encoder)(nil).Encode(t7)
(*json.Encoder)(nil).Encode(t8) // want `struct type 'CheckNoopMarshal.T8' doesn't have any exported fields, nor custom marshaling`
(*xml.Decoder)(nil).Decode(&t7) // want `struct type 'CheckNoopMarshal.T7' doesn't have any exported fields, nor custom marshaling`
(*xml.Decoder)(nil).Decode(&t8)
(*xml.Encoder)(nil).Encode(t7) // want `struct type 'CheckNoopMarshal.T7' doesn't have any exported fields, nor custom marshaling`
(*xml.Encoder)(nil).Encode(t8)
}
var _, _ = json.Marshal(T9{})
go-tools-2021.1.2/staticcheck/testdata/src/CheckPrintf/ 0000775 0000000 0000000 00000000000 14143223131 0022561 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckPrintf/CheckPrintf.go 0000664 0000000 0000000 00000036414 14143223131 0025320 0 ustar 00root root 0000000 0000000 // Package pkg is amazing.
package pkg
import (
"fmt"
"math/big"
"os"
"unsafe"
)
type Error int
func (Error) Error() string { return "" }
func fn() {
var b bool
var i int
var r rune
var s string
var x float64
var p *int
var imap map[int]int
var fslice []float64
var c complex64
// Some good format/argtypes
fmt.Printf("")
fmt.Printf("%b %b %b", 3, i, x)
fmt.Printf("%c %c %c %c", 3, i, 'x', r)
fmt.Printf("%d %d %d", 3, i, imap)
fmt.Printf("%e %e %e %e", 3e9, x, fslice, c)
fmt.Printf("%E %E %E %E", 3e9, x, fslice, c)
fmt.Printf("%f %f %f %f", 3e9, x, fslice, c)
fmt.Printf("%F %F %F %F", 3e9, x, fslice, c)
fmt.Printf("%g %g %g %g", 3e9, x, fslice, c)
fmt.Printf("%G %G %G %G", 3e9, x, fslice, c)
fmt.Printf("%b %b %b %b", 3e9, x, fslice, c)
fmt.Printf("%o %o", 3, i)
fmt.Printf("%p", p)
fmt.Printf("%q %q %q %q", 3, i, 'x', r)
fmt.Printf("%s %s %s", "hi", s, []byte{65})
fmt.Printf("%t %t", true, b)
fmt.Printf("%T %T", 3, i)
fmt.Printf("%U %U", 3, i)
fmt.Printf("%v %v", 3, i)
fmt.Printf("%x %x %x %x", 3, i, "hi", s)
fmt.Printf("%X %X %X %X", 3, i, "hi", s)
fmt.Printf("%.*s %d %g", 3, "hi", 23, 2.3)
fmt.Printf("%s", &stringerv)
fmt.Printf("%v", &stringerv)
fmt.Printf("%T", &stringerv)
fmt.Printf("%s", &embeddedStringerv)
fmt.Printf("%v", &embeddedStringerv)
fmt.Printf("%T", &embeddedStringerv)
fmt.Printf("%v", notstringerv)
fmt.Printf("%T", notstringerv)
fmt.Printf("%q", stringerarrayv)
fmt.Printf("%v", stringerarrayv)
fmt.Printf("%s", stringerarrayv)
fmt.Printf("%v", notstringerarrayv)
fmt.Printf("%T", notstringerarrayv)
fmt.Printf("%d", new(fmt.Formatter))
fmt.Printf("%f", new(big.Float))
fmt.Printf("%*%", 2) // Ridiculous but allowed.
fmt.Printf("%s", interface{}(nil)) // Nothing useful we can say.
fmt.Printf("%g", 1+2i)
fmt.Printf("%#e %#E %#f %#F %#g %#G", 1.2, 1.2, 1.2, 1.2, 1.2, 1.2) // OK since Go 1.9
// Some bad format/argTypes
fmt.Printf("%b", "hi") // want `Printf format %b has arg #1 of wrong type string`
_ = fmt.Sprintf("%b", "hi") // want `Printf format %b has arg #1 of wrong type string`
fmt.Fprintf(os.Stdout, "%b", "hi") // want `Printf format %b has arg #1 of wrong type string`
fmt.Printf("%t", c) // want `Printf format %t has arg #1 of wrong type complex64`
fmt.Printf("%t", 1+2i) // want `Printf format %t has arg #1 of wrong type complex128`
fmt.Printf("%c", 2.3) // want `Printf format %c has arg #1 of wrong type float64`
fmt.Printf("%d", 2.3) // want `Printf format %d has arg #1 of wrong type float64`
fmt.Printf("%e", "hi") // want `Printf format %e has arg #1 of wrong type string`
fmt.Printf("%E", true) // want `Printf format %E has arg #1 of wrong type bool`
fmt.Printf("%f", "hi") // want `Printf format %f has arg #1 of wrong type string`
fmt.Printf("%F", 'x') // want `Printf format %F has arg #1 of wrong type rune`
fmt.Printf("%g", "hi") // want `Printf format %g has arg #1 of wrong type string`
fmt.Printf("%g", imap) // want `Printf format %g has arg #1 of wrong type map\[int\]int`
fmt.Printf("%G", i) // want `Printf format %G has arg #1 of wrong type int`
fmt.Printf("%o", x) // want `Printf format %o has arg #1 of wrong type float64`
fmt.Printf("%p", 23) // want `Printf format %p has arg #1 of wrong type int`
fmt.Printf("%q", x) // want `Printf format %q has arg #1 of wrong type float64`
fmt.Printf("%s", b) // want `Printf format %s has arg #1 of wrong type bool`
fmt.Printf("%s", byte(65)) // want `Printf format %s has arg #1 of wrong type byte`
fmt.Printf("%t", 23) // want `Printf format %t has arg #1 of wrong type int`
fmt.Printf("%U", x) // want `Printf format %U has arg #1 of wrong type float64`
fmt.Printf("%X", 2.3)
fmt.Printf("%X", 2+3i)
fmt.Printf("%s", stringerv) // want `Printf format %s has arg #1 of wrong type CheckPrintf\.ptrStringer`
fmt.Printf("%t", stringerv) // want `Printf format %t has arg #1 of wrong type CheckPrintf\.ptrStringer`
fmt.Printf("%s", embeddedStringerv) // want `Printf format %s has arg #1 of wrong type CheckPrintf\.embeddedStringer`
fmt.Printf("%t", embeddedStringerv) // want `Printf format %t has arg #1 of wrong type CheckPrintf\.embeddedStringer`
fmt.Printf("%q", notstringerv) // want `Printf format %q has arg #1 of wrong type CheckPrintf\.notstringer`
fmt.Printf("%t", notstringerv) // want `Printf format %t has arg #1 of wrong type CheckPrintf\.notstringer`
fmt.Printf("%t", stringerarrayv) // want `Printf format %t has arg #1 of wrong type CheckPrintf\.stringerarray`
fmt.Printf("%t", notstringerarrayv) // want `Printf format %t has arg #1 of wrong type CheckPrintf\.notstringerarray`
fmt.Printf("%q", notstringerarrayv) // want `Printf format %q has arg #1 of wrong type CheckPrintf\.notstringerarray`
fmt.Printf("%d", BoolFormatter(true)) // want `Printf format %d has arg #1 of wrong type CheckPrintf\.BoolFormatter`
fmt.Printf("%z", FormatterVal(true)) // correct (the type is responsible for formatting)
fmt.Printf("%d", FormatterVal(true)) // correct (the type is responsible for formatting)
fmt.Printf("%s", nonemptyinterface) // correct (the type is responsible for formatting)
fmt.Printf("%.*s %d %6g", 3, "hi", 23, 'x') // want `Printf format %6g has arg #4 of wrong type rune`
fmt.Printf("%s", "hi", 3) // want `Printf call needs 1 args but has 2 args`
fmt.Printf("%"+("s"), "hi", 3) // want `Printf call needs 1 args but has 2 args`
fmt.Printf("%s%%%d", "hi", 3) // correct
fmt.Printf("%08s", "woo") // correct
fmt.Printf("% 8s", "woo") // correct
fmt.Printf("%.*d", 3, 3) // correct
fmt.Printf("%.*d x", 3, 3, 3, 3) // want `Printf call needs 2 args but has 4 args`
fmt.Printf("%.*d x", "hi", 3) // want `Printf format %\.\*d reads non-int arg #1 as argument of \*`
fmt.Printf("%.*d x", i, 3) // correct
fmt.Printf("%.*d x", s, 3) // want `Printf format %\.\*d reads non-int arg #1 as argument of \*`
fmt.Printf("%*% x", 0.22) // want `Printf format %\*% reads non-int arg #1 as argument of \*`
fmt.Printf("%q %q", multi()...) // ok
fmt.Printf("%#q", `blah`) // ok
const format = "%s %s\n"
fmt.Printf(format, "hi", "there")
fmt.Printf(format, "hi") // want `Printf format %s reads arg #2, but call has only 1 args`
fmt.Printf("%s %d %.3v %q", "str", 4) // want `Printf format %\.3v reads arg #3, but call has only 2 args`
fmt.Printf("%#s", FormatterVal(true)) // correct (the type is responsible for formatting)
fmt.Printf("d%", 2) // want `couldn't parse format string`
fmt.Printf("%d", percentDV)
fmt.Printf("%d", &percentDV)
fmt.Printf("%d", notPercentDV) // want `Printf format %d has arg #1 of wrong type CheckPrintf\.notPercentDStruct`
fmt.Printf("%d", ¬PercentDV) // want `Printf format %d has arg #1 of wrong type \*CheckPrintf\.notPercentDStruct`
fmt.Printf("%p", ¬PercentDV) // Works regardless: we print it as a pointer.
fmt.Printf("%q", &percentDV) // want `Printf format %q has arg #1 of wrong type \*CheckPrintf\.percentDStruct`
fmt.Printf("%s", percentSV)
fmt.Printf("%s", &percentSV)
// Good argument reorderings.
fmt.Printf("%[1]d", 3)
fmt.Printf("%[1]*d", 3, 1)
fmt.Printf("%[2]*[1]d", 1, 3)
fmt.Printf("%[2]*.[1]*[3]d", 2, 3, 4)
fmt.Fprintf(os.Stderr, "%[2]*.[1]*[3]d", 2, 3, 4) // Use Fprintf to make sure we count arguments correctly.
// Bad argument reorderings.
fmt.Printf("%[xd", 3) // want `couldn't parse format string`
fmt.Printf("%[x]d x", 3) // want `couldn't parse format string`
fmt.Printf("%[3]*s x", "hi", 2) // want `Printf format %\[3\]\*s reads arg #3, but call has only 2 args`
fmt.Printf("%[3]d x", 2) // want `Printf format %\[3\]d reads arg #3, but call has only 1 args`
fmt.Printf("%[2]*.[1]*[3]d x", 2, "hi", 4) // want `Printf format %\[2\]\*\.\[1\]\*\[3\]d reads non-int arg #2 as argument of \*`
fmt.Printf("%[0]s x", "arg1") // want `Printf format %\[0\]s reads invalid arg 0; indices are 1-based`
fmt.Printf("%[0]d x", 1) // want `Printf format %\[0\]d reads invalid arg 0; indices are 1-based`
// Interfaces can be used with any verb.
var iface interface {
ToTheMadness() bool // Method ToTheMadness usually returns false
}
fmt.Printf("%f", iface) // ok: fmt treats interfaces as transparent and iface may well have a float concrete type
// Can print functions in many ways
fmt.Printf("%s", someFunction) // want `Printf format %s has arg #1 of wrong type func\(\)`
fmt.Printf("%d", someFunction) // ok: maybe someone wants to see the pointer
fmt.Printf("%v", someFunction) // ok: maybe someone wants to see the pointer in decimal
fmt.Printf("%p", someFunction) // ok: maybe someone wants to see the pointer
fmt.Printf("%T", someFunction) // ok: maybe someone wants to see the type
// Bug: used to recur forever.
fmt.Printf("%p %x", recursiveStructV, recursiveStructV.next)
fmt.Printf("%p %x", recursiveStruct1V, recursiveStruct1V.next)
fmt.Printf("%p %x", recursiveSliceV, recursiveSliceV)
//fmt.Printf("%p %x", recursiveMapV, recursiveMapV)
// indexed arguments
fmt.Printf("%d %[3]d %d %[2]d x", 1, 2, 3, 4) // OK
fmt.Printf("%d %[0]d %d %[2]d x", 1, 2, 3, 4) // want `Printf format %\[0\]d reads invalid arg 0; indices are 1-based`
fmt.Printf("%d %[3]d %d %[-2]d x", 1, 2, 3, 4) // want `couldn't parse format string`
fmt.Printf("%d %[3]d %d %[5]d x", 1, 2, 3, 4) // want `Printf format %\[5\]d reads arg #5, but call has only 4 args`
fmt.Printf("%d %[3]d %-10d %[2]d x", 1, 2, 3) // want `Printf format %-10d reads arg #4, but call has only 3 args`
fmt.Printf("%[1][3]d x", 1, 2) // want `couldn't parse format string`
fmt.Printf("%[1]d x", 1, 2) // OK
fmt.Printf("%d %[3]d %d %[2]d x", 1, 2, 3, 4, 5) // OK
fmt.Printf(someString(), "hello") // OK
// d accepts pointers as long as they're not to structs.
// pointers to structs are dereferenced and walked.
fmt.Printf("%d", &s)
// staticcheck's own checks, based on bugs in go vet; see https://github.com/golang/go/issues/27672
{
type T2 struct {
X string
}
type T1 struct {
X *T2
}
x1 := []string{"hi"}
t1 := T1{&T2{"hi"}}
fmt.Printf("%s\n", &x1)
fmt.Printf("%s\n", t1) // want `Printf format %s has arg #1 of wrong type CheckPrintf\.T1`
var x2 struct{ A *int }
fmt.Printf("%p\n", x2) // want `Printf format %p has arg #1 of wrong type struct\{A \*int\}`
var x3 [2]int
fmt.Printf("%p", x3) // want `Printf format %p has arg #1 of wrong type \[2\]int`
ue := unexportedError{nil}
fmt.Printf("%s", ue)
}
// staticcheck's own checks, based on our own bugs
fmt.Printf("%s", Error(0))
fmt.Printf("%x", unsafe.Pointer(uintptr(0)))
}
func someString() string { return "X" }
// A function we use as a function value; it has no other purpose.
func someFunction() {}
// multi is used by the test.
func multi() []interface{} {
return nil
}
type stringer int
func (stringer) String() string { return "string" }
type ptrStringer float64
var stringerv ptrStringer
func (*ptrStringer) String() string {
return "string"
}
type embeddedStringer struct {
foo string
ptrStringer
bar int
}
var embeddedStringerv embeddedStringer
type notstringer struct {
f float64
}
var notstringerv notstringer
type stringerarray [4]float64
func (stringerarray) String() string {
return "string"
}
var stringerarrayv stringerarray
type notstringerarray [4]float64
var notstringerarrayv notstringerarray
var nonemptyinterface = interface {
f()
}(nil)
// A data type we can print with "%d".
type percentDStruct struct {
a int
b []byte
c *float64
}
var percentDV percentDStruct
// A data type we cannot print correctly with "%d".
type notPercentDStruct struct {
a int
b []byte
c bool
}
var notPercentDV notPercentDStruct
// A data type we can print with "%s".
type percentSStruct struct {
a string
b []byte
C stringerarray
}
var percentSV percentSStruct
type BoolFormatter bool
func (*BoolFormatter) Format(fmt.State, rune) {
}
// Formatter with value receiver
type FormatterVal bool
func (FormatterVal) Format(fmt.State, rune) {
}
type RecursiveSlice []RecursiveSlice
var recursiveSliceV = &RecursiveSlice{}
type RecursiveMap map[int]RecursiveMap
var recursiveMapV = make(RecursiveMap)
type RecursiveStruct struct {
next *RecursiveStruct
}
var recursiveStructV = &RecursiveStruct{}
type RecursiveStruct1 struct {
next *RecursiveStruct2
}
type RecursiveStruct2 struct {
next *RecursiveStruct1
}
var recursiveStruct1V = &RecursiveStruct1{}
type unexportedInterface struct {
f interface{}
}
// Issue 17798: unexported ptrStringer cannot be formatted.
type unexportedStringer struct {
t ptrStringer
}
type unexportedStringerOtherFields struct {
s string
t ptrStringer
S string
}
// Issue 17798: unexported error cannot be formatted.
type unexportedError struct {
e error
}
type unexportedErrorOtherFields struct {
s string
e error
S string
}
type errorer struct{}
func (e errorer) Error() string { return "errorer" }
type unexportedCustomError struct {
e errorer
}
type errorInterface interface {
error
ExtraMethod()
}
type unexportedErrorInterface struct {
e errorInterface
}
func UnexportedStringerOrError() {
fmt.Printf("%s", unexportedInterface{"foo"}) // ok; prints {foo}
fmt.Printf("%s", unexportedInterface{3}) // ok; we can't see the problem
us := unexportedStringer{}
fmt.Printf("%s", us) // want `Printf format %s has arg #1 of wrong type CheckPrintf\.unexportedStringer`
fmt.Printf("%s", &us) // want `Printf format %s has arg #1 of wrong type \*CheckPrintf\.unexportedStringer`
usf := unexportedStringerOtherFields{
s: "foo",
S: "bar",
}
fmt.Printf("%s", usf) // want `Printf format %s has arg #1 of wrong type CheckPrintf\.unexportedStringerOtherFields`
fmt.Printf("%s", &usf) // want `Printf format %s has arg #1 of wrong type \*CheckPrintf\.unexportedStringerOtherFields`
intSlice := []int{3, 4}
fmt.Printf("%s", intSlice) // want `Printf format %s has arg #1 of wrong type \[\]int`
nonStringerArray := [1]unexportedStringer{{}}
fmt.Printf("%s", nonStringerArray) // want `Printf format %s has arg #1 of wrong type \[1\]CheckPrintf\.unexportedStringer`
fmt.Printf("%s", []stringer{3, 4}) // not an error
fmt.Printf("%s", [2]stringer{3, 4}) // not an error
}
// TODO: Disable complaint about '0' for Go 1.10. To be fixed properly in 1.11.
// See issues 23598 and 23605.
func DisableErrorForFlag0() {
fmt.Printf("%0t", true)
}
// Issue 26486.
func dbg(format string, args ...interface{}) {
if format == "" {
format = "%v"
}
fmt.Printf(format, args...)
}
// https://github.com/dominikh/go-tools/issues/714
func fn2() {
type String string
type Byte byte
var a string = "a"
var b []byte = []byte{'b'}
var c [1]byte = [1]byte{'c'}
var d String = "d"
var e []uint8 = []uint8{'e'}
var f []Byte = []Byte{'h'}
fmt.Printf("%s %s %s %s %s %s %s", a, b, c, &c, d, e, f)
}
func fn3() {
s := "%d"
if true {
fmt.Printf(s, "") // want `Printf format`
} else {
_ = s
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckPureFunctions/ 0000775 0000000 0000000 00000000000 14143223131 0024123 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckPureFunctions/CheckPureFunctions.go 0000664 0000000 0000000 00000001746 14143223131 0030224 0 ustar 00root root 0000000 0000000 package pkg
import (
"context"
"fmt"
"net/http"
"strings"
)
func fn1() {
strings.Replace("", "", "", 1) // want `is a pure function but its return value is ignored`
foo(1, 2) // want `is a pure function but its return value is ignored`
baz(1, 2) // want `is a pure function but its return value is ignored`
_, x := baz(1, 2)
_ = x
bar(1, 2)
}
func fn2() {
r, _ := http.NewRequest("GET", "/", nil)
r.WithContext(context.Background()) // want `is a pure function but its return value is ignored`
}
func foo(a, b int) int { return a + b }
func baz(a, b int) (int, int) { return a + b, a + b }
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 fn4() error {
// Test for https://github.com/dominikh/go-tools/issues/949
if true {
return fmt.Errorf("")
}
for {
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckPureFunctions/CheckPureFunctions_test.go 0000664 0000000 0000000 00000000567 14143223131 0031263 0 ustar 00root root 0000000 0000000 package pkg
import (
"strings"
"testing"
)
func TestFoo(t *testing.T) {
strings.Replace("", "", "", 1) // want `is a pure function but its return value is ignored`
}
func BenchmarkFoo(b *testing.B) {
strings.Replace("", "", "", 1)
}
func doBenchmark(s string, b *testing.B) {
strings.Replace("", "", "", 1)
}
func BenchmarkBar(b *testing.B) {
doBenchmark("", b)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckRangeStringRunes/ 0000775 0000000 0000000 00000000000 14143223131 0024557 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckRangeStringRunes/CheckRangeStringRunes.go 0000664 0000000 0000000 00000000757 14143223131 0031315 0 ustar 00root root 0000000 0000000 package pkg
type String string
func fn(s string, s2 String) {
for _, r := range s {
println(r)
}
for _, r := range []rune(s) { // want `should range over string`
println(r)
}
for i, r := range []rune(s) {
println(i)
println(r)
}
x := []rune(s)
for _, r := range x { // want `should range over string`
println(r)
}
y := []rune(s)
for _, r := range y {
println(r)
}
println(y[0])
for _, r := range []rune(s2) { // want `should range over string`
println(r)
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckRegexpMatchLoop/ 0000775 0000000 0000000 00000000000 14143223131 0024360 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckRegexpMatchLoop/CheckRegexpMatchLoop.go 0000664 0000000 0000000 00000000660 14143223131 0030710 0 ustar 00root root 0000000 0000000 package pkg
import "regexp"
func fn() {
regexp.Match(".", nil)
regexp.MatchString(".", "")
regexp.MatchReader(".", nil)
for {
regexp.Match(".", nil) // want `calling regexp\.Match in a loop has poor performance`
regexp.MatchString(".", "") // want `calling regexp\.MatchString in a loop has poor performance`
regexp.MatchReader(".", nil) // want `calling regexp\.MatchReader in a loop has poor performance`
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckRegexps/ 0000775 0000000 0000000 00000000000 14143223131 0022734 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckRegexps/CheckRegexps.go 0000664 0000000 0000000 00000002123 14143223131 0025634 0 ustar 00root root 0000000 0000000 package pkg
import (
"log"
"regexp"
)
const c1 = `[`
const c2 = `(abc)`
var re1 = regexp.MustCompile(`ab\yef`) // want `error parsing regexp`
var re2 = regexp.MustCompile(c1) // want `error parsing regexp`
var re3 = regexp.MustCompile(c2)
var re4 = regexp.MustCompile(
c1, // want `error parsing regexp`
)
func fn() {
_, err := regexp.Compile(`foo(`) // want `error parsing regexp`
if err != nil {
panic(err)
}
if re2.MatchString("foo(") {
log.Println("of course 'foo(' matches 'foo('")
}
regexp.Match("foo(", nil) // want `error parsing regexp`
regexp.MatchReader("foo(", nil) // want `error parsing regexp`
regexp.MatchString("foo(", "") // want `error parsing regexp`
}
// must be a basic type to trigger SA4017 (in case of a test failure)
type T string
func (T) Fn() {}
// Don't get confused by methods named init
func (T) init() {}
// this will become a synthetic init function, that we don't want to
// ignore
var _ = regexp.MustCompile("(") // want `error parsing regexp`
func fn2() {
regexp.MustCompile("foo(").FindAll(nil, 0) // want `error parsing regexp`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckRepeatedIfElse/ 0000775 0000000 0000000 00000000000 14143223131 0024140 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckRepeatedIfElse/CheckRepeatedIfElse.go 0000664 0000000 0000000 00000001433 14143223131 0030247 0 ustar 00root root 0000000 0000000 package pkg
func fn1(b1, b2 bool) {
if b1 && !b2 {
} else if b1 {
} else if b1 && !b2 { // want `condition occurs multiple times`
} else if b1 { // want `condition occurs multiple times`
} else {
println()
}
}
func fn2(b1, b2 bool, ch chan string) {
if b1 && !b2 {
} else if b1 {
} else if <-ch == "" {
} else if <-ch == "" {
} else {
println()
}
}
func fn3() {
if gen() {
println()
} else if gen() {
println()
}
}
func fn4() {
if s := gen2(); s == "" {
} else if s := gen2(); s == "" {
println()
}
}
func fn5() {
var s string
if s = gen2(); s == "" {
} else if s != "foo" {
} else if s = gen2(); s == "" {
} else if s != "foo" {
println()
}
}
func fn6() {
if true {
} else {
}
}
func gen() bool { return false }
func gen2() string { return "" }
go-tools-2021.1.2/staticcheck/testdata/src/CheckScopedBreak/ 0000775 0000000 0000000 00000000000 14143223131 0023501 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckScopedBreak/CheckScopedBreak.go 0000664 0000000 0000000 00000001504 14143223131 0027150 0 ustar 00root root 0000000 0000000 package pkg
func fn() {
var ch chan int
for {
switch {
case true:
break // want `ineffective break statement`
default:
break // want `ineffective break statement`
}
}
for {
select {
case <-ch:
break // want `ineffective break statement`
}
}
for {
switch {
case true:
}
switch {
case true:
break // want `ineffective break statement`
}
switch {
case true:
}
}
for {
switch {
case true:
if true {
break // want `ineffective break statement`
} else {
break // want `ineffective break statement`
}
}
}
for {
switch {
case true:
if true {
break
}
println("do work")
}
}
label:
for {
switch {
case true:
break label
}
}
for range ([]int)(nil) {
switch {
default:
break // want `ineffective break statement`
}
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckSelfAssignment/ 0000775 0000000 0000000 00000000000 14143223131 0024241 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckSelfAssignment/CheckSelfAssignment.go 0000664 0000000 0000000 00000002554 14143223131 0030456 0 ustar 00root root 0000000 0000000 package pkg
func fn(x int) {
var z int
var y int
x = x // want `self-assignment`
y = y // want `self-assignment`
y, x, z = y, x, 1 // want `self-assignment of y to y` `self-assignment of x to x`
y = x
_ = y
_ = x
_ = z
func() {
x := x
println(x)
}()
}
func fn1() {
var (
x []byte
ch chan int
)
x[42] = x[42] // want `self-assignment`
x[pure(42)] = x[pure(42)] // want `self-assignment`
x[pure(pure(42))] = x[pure(pure(42))] // want `self-assignment`
x[impure(42)] = x[impure(42)]
x[impure(pure(42))] = x[impure(pure(42))]
x[pure(impure(42))] = x[pure(impure(42))]
x[pure(<-ch)] = x[pure(<-ch)]
x[pure(pure(<-ch))] = x[pure(pure(<-ch))]
x[<-ch] = x[<-ch]
type T struct {
x []int
}
var ts []T
ts[impure(42)].x = ts[impure(42)].x
m := map[*int]int{}
m[ptr1()] = m[ptr1()]
m[ptr2()] = m[ptr2()]
m[new(int)] = m[new(int)]
m2 := map[int]int{}
m2[len(x)] = m2[len(x)] // want `self-assignment`
gen1()[0] = gen1()[0]
gen2(0)[0] = gen2(0)[0] // want `self-assignment`
gen3(0)[0] = gen3(0)[0]
}
func ptr1() *int {
return new(int)
}
func ptr2() *int {
x := 0
return &x
}
func gen1() []int {
return nil
}
func gen2(x int) []int {
return nil
}
func gen3(x int) []int {
return make([]int, 0)
}
func pure(n int) int {
return n
}
func impure(n int) int {
println(n)
return n
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckSillyBitwiseOps/ 0000775 0000000 0000000 00000000000 14143223131 0024424 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckSillyBitwiseOps/CheckSillyBitwiseOps.go 0000664 0000000 0000000 00000001126 14143223131 0031016 0 ustar 00root root 0000000 0000000 package pkg
const a = 0
const (
b = iota
c
)
const (
y = 42
d = iota
)
func fn(x int) {
println(x | 0) // want `x \| 0 always equals x`
println(x & 0) // want `x & 0 always equals 0`
println(x ^ 0) // want `x \^ 0 always equals x`
println((x << 5) | 0) // want `\(x << 5\) \| 0 always equals \(x << 5\)`
println(x | 1)
println(x << 0)
println(x | a)
println(x | b) // want `x \| b always equals x; b is defined as iota`
println(x & b) // want `x & b always equals 0; b is defined as iota`
println(x | c)
// d is iota, but its value is 1
println(x | d)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckSillyBitwiseOps_dotImport/ 0000775 0000000 0000000 00000000000 14143223131 0026465 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckSillyBitwiseOps_dotImport/foo.go 0000664 0000000 0000000 00000000031 14143223131 0027571 0 ustar 00root root 0000000 0000000 package foo
const X = 0
go-tools-2021.1.2/staticcheck/testdata/src/CheckSillyBitwiseOps_dotImport/foo_test.go 0000664 0000000 0000000 00000000113 14143223131 0030631 0 ustar 00root root 0000000 0000000 package foo_test
import . "CheckSillyBitwiseOps_dotImport"
var _ = 1 | X
go-tools-2021.1.2/staticcheck/testdata/src/CheckSillyBitwiseOps_shadowedIota/ 0000775 0000000 0000000 00000000000 14143223131 0027117 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckSillyBitwiseOps_shadowedIota/shadowed.go 0000664 0000000 0000000 00000000120 14143223131 0031235 0 ustar 00root root 0000000 0000000 package pkg
const iota = 0
const (
a = iota
)
func fn(x int) {
_ = x | a
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckSillyRegexp.disabled/ 0000775 0000000 0000000 00000000000 14143223131 0025334 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckSillyRegexp.disabled/CheckSillyRegexp.go 0000664 0000000 0000000 00000000507 14143223131 0031072 0 ustar 00root root 0000000 0000000 package pkg
import "regexp"
func fn() {
regexp.Compile("") // MATCH "does not contain any meta characters"
regexp.Compile("abc") // MATCH "does not contain any meta characters"
regexp.Compile("abc\\.def") // MATCH "does not contain any meta characters"
regexp.Compile("abc.def")
regexp.Compile("(abc)")
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckSingleArgAppend/ 0000775 0000000 0000000 00000000000 14143223131 0024322 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckSingleArgAppend/CheckSingleArgAppend.go 0000664 0000000 0000000 00000000563 14143223131 0030616 0 ustar 00root root 0000000 0000000 package pkg
func fn(arg []int) {
x := append(arg) // want `x = append\(y\) is equivalent to x = y`
_ = x
y := append(arg, 1)
_ = y
arg = append(arg) // want `x = append\(y\) is equivalent to x = y`
arg = append(arg, 1, 2, 3)
var nilly []int
arg = append(arg, nilly...)
arg = append(arg, arg...)
append := func([]int) []int { return nil }
arg = append(arg)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckSortSlice/ 0000775 0000000 0000000 00000000000 14143223131 0023226 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckSortSlice/slice.go 0000664 0000000 0000000 00000002203 14143223131 0024651 0 ustar 00root root 0000000 0000000 package pkg
import "sort"
type T1 []int
type T2 T1
type T3 [1]int
type T4 string
func fn(arg1 interface{}, arg2 []int) {
var v1 T1
var v2 T2
var v3 T3
var v4 T4
var v5 []int
var v6 interface{} = []int{}
var v7 interface{}
if true {
v7 = []int{}
} else {
v7 = 0
}
var v8 interface{} = 0
sort.Slice(arg1, nil)
sort.Slice(arg2, nil)
sort.Slice(v1, nil)
sort.Slice(v2, nil)
sort.Slice(v3, nil) // want `sort\.Slice must only be called on slices, was called on \[1\]int`
sort.Slice(v4, nil) // want `sort\.Slice must only be called on slices, was called on string`
sort.Slice(v5, nil)
sort.Slice(v6, nil)
sort.Slice(v7, nil)
sort.Slice(v8, nil) // want `sort\.Slice must only be called on slices, was called on int`
sort.Slice([]int{}, nil)
sort.Slice(0, nil) // want `sort\.Slice must only be called on slices, was called on int`
sort.Slice(nil, nil) // want `cannot call sort\.Slice on nil literal`
sort.SliceIsSorted(0, nil) // want `sort\.SliceIsSorted must only be called on slices, was called on int`
sort.SliceStable(0, nil) // want `sort\.SliceStable must only be called on slices, was called on int`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckStaticBitShift/ 0000775 0000000 0000000 00000000000 14143223131 0024203 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckStaticBitShift/CheckStaticBitShift.go 0000664 0000000 0000000 00000005206 14143223131 0030357 0 ustar 00root root 0000000 0000000 package pkg
// Partially copied from go vet's test suite.
// Copyright 2014 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-THIRD-PARTY file.
type Number int8
func fn() {
var n8 Number
n8 <<= 8 // want `will always clear it`
var i8 int8
_ = i8 << 7
_ = (i8 + 1) << 8 // want `will always clear it`
_ = i8 << (7 + 1) // want `will always clear it`
_ = i8 >> 8 // want `will always clear it`
i8 <<= 8 // want `will always clear it`
i8 >>= 8 // want `will always clear it`
i8 <<= 12 // want `will always clear it`
var i16 int16
_ = i16 << 15
_ = i16 << 16 // want `will always clear it`
_ = i16 >> 16 // want `will always clear it`
i16 <<= 16 // want `will always clear it`
i16 >>= 16 // want `will always clear it`
i16 <<= 18 // want `will always clear it`
var i32 int32
_ = i32 << 31
_ = i32 << 32 // want `will always clear it`
_ = i32 >> 32 // want `will always clear it`
i32 <<= 32 // want `will always clear it`
i32 >>= 32 // want `will always clear it`
i32 <<= 40 // want `will always clear it`
var i64 int64
_ = i64 << 63
_ = i64 << 64 // want `will always clear it`
_ = i64 >> 64 // want `will always clear it`
i64 <<= 64 // want `will always clear it`
i64 >>= 64 // want `will always clear it`
i64 <<= 70 // want `will always clear it`
var u8 uint8
_ = u8 << 7
_ = u8 << 8 // want `will always clear it`
_ = u8 >> 8 // want `will always clear it`
u8 <<= 8 // want `will always clear it`
u8 >>= 8 // want `will always clear it`
u8 <<= 12 // want `will always clear it`
var u16 uint16
_ = u16 << 15
_ = u16 << 16 // want `will always clear it`
_ = u16 >> 16 // want `will always clear it`
u16 <<= 16 // want `will always clear it`
u16 >>= 16 // want `will always clear it`
u16 <<= 18 // want `will always clear it`
var u32 uint32
_ = u32 << 31
_ = u32 << 32 // want `will always clear it`
_ = u32 >> 32 // want `will always clear it`
u32 <<= 32 // want `will always clear it`
u32 >>= 32 // want `will always clear it`
u32 <<= 40 // want `will always clear it`
var u64 uint64
_ = u64 << 63
_ = u64 << 64 // want `will always clear it`
_ = u64 >> 64 // want `will always clear it`
u64 <<= 64 // want `will always clear it`
u64 >>= 64 // want `will always clear it`
u64 <<= 70 // want `will always clear it`
_ = u64 << u64
}
func fn1() {
var ui uint
_ = ui << 64
_ = ui >> 64
ui <<= 64
ui >>= 64
var uptr uintptr
_ = uptr << 64
_ = uptr >> 64
uptr <<= 64
uptr >>= 64
var i int
_ = i << 64
_ = i >> 64
i <<= 64
i >>= 64
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckStrconv/ 0000775 0000000 0000000 00000000000 14143223131 0022755 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckStrconv/CheckStrconv.go 0000664 0000000 0000000 00000006650 14143223131 0025707 0 ustar 00root root 0000000 0000000 package pkg
import "strconv"
func fn() {
strconv.ParseFloat("", 16) // want `'bitSize' argument is invalid, must be either 32 or 64`
strconv.ParseFloat("", 32)
strconv.ParseFloat("", 64)
strconv.ParseFloat("", 128) // want `'bitSize' argument is invalid, must be either 32 or 64`
strconv.ParseInt("", 0, -1) // want `'bitSize' argument is invalid, must be within 0 and 64`
strconv.ParseInt("", 0, 0)
strconv.ParseInt("", 0, 1)
strconv.ParseInt("", 0, 64)
strconv.ParseInt("", 0, 65) // want `'bitSize' argument is invalid, must be within 0 and 64`
strconv.ParseInt("", -1, 0) // want `'base' must not be smaller than 2, unless it is 0`
strconv.ParseInt("", 1, 0) // want `'base' must not be smaller than 2, unless it is 0`
strconv.ParseInt("", 2, 0)
strconv.ParseInt("", 10, 0)
strconv.ParseInt("", 36, 0)
strconv.ParseInt("", 37, 0) // want `'base' must not be larger than 36`
strconv.ParseUint("", 0, -1) // want `'bitSize' argument is invalid, must be within 0 and 64`
strconv.ParseUint("", 0, 0)
strconv.ParseUint("", 0, 1)
strconv.ParseUint("", 0, 64)
strconv.ParseUint("", 0, 65) // want `'bitSize' argument is invalid, must be within 0 and 64`
strconv.ParseUint("", -1, 0) // want `'base' must not be smaller than 2, unless it is 0`
strconv.ParseUint("", 1, 0) // want `'base' must not be smaller than 2, unless it is 0`
strconv.ParseUint("", 2, 0)
strconv.ParseUint("", 10, 0)
strconv.ParseUint("", 36, 0)
strconv.ParseUint("", 37, 0) // want `'base' must not be larger than 36`
strconv.FormatFloat(0, 'e', 0, 18) // want `'bitSize' argument is invalid, must be either 32 or 64`
strconv.FormatFloat(0, 'e', 0, 32)
strconv.FormatFloat(0, 'e', 0, 64)
strconv.FormatFloat(0, 'e', 0, 128) // want `'bitSize' argument is invalid, must be either 32 or 64`
strconv.FormatFloat(0, 'j', 0, 32) // want `'fmt' argument is invalid: unknown format 'j'`
strconv.FormatInt(0, 0) // want `'base' must not be smaller than 2`
strconv.FormatInt(0, 1) // want `'base' must not be smaller than 2`
strconv.FormatInt(0, 2)
strconv.FormatInt(0, 3)
strconv.FormatInt(0, 36)
strconv.FormatInt(0, 37) // want `'base' must not be larger than 36`
strconv.FormatUint(0, 0) // want `'base' must not be smaller than 2`
strconv.FormatUint(0, 1) // want `'base' must not be smaller than 2`
strconv.FormatUint(0, 2)
strconv.FormatUint(0, 3)
strconv.FormatUint(0, 36)
strconv.FormatUint(0, 37) // want `'base' must not be larger than 36`
strconv.AppendFloat(nil, 0, 'e', 0, 18) // want `'bitSize' argument is invalid, must be either 32 or 64`
strconv.AppendFloat(nil, 0, 'e', 0, 32)
strconv.AppendFloat(nil, 0, 'e', 0, 64)
strconv.AppendFloat(nil, 0, 'e', 0, 128) // want `'bitSize' argument is invalid, must be either 32 or 64`
strconv.AppendFloat(nil, 0, 'j', 0, 32) // want `'fmt' argument is invalid: unknown format 'j'`
strconv.AppendInt(nil, 0, 0) // want `'base' must not be smaller than 2`
strconv.AppendInt(nil, 0, 1) // want `'base' must not be smaller than 2`
strconv.AppendInt(nil, 0, 2)
strconv.AppendInt(nil, 0, 3)
strconv.AppendInt(nil, 0, 36)
strconv.AppendInt(nil, 0, 37) // want `'base' must not be larger than 36`
strconv.AppendUint(nil, 0, 0) // want `'base' must not be smaller than 2`
strconv.AppendUint(nil, 0, 1) // want `'base' must not be smaller than 2`
strconv.AppendUint(nil, 0, 2)
strconv.AppendUint(nil, 0, 3)
strconv.AppendUint(nil, 0, 36)
strconv.AppendUint(nil, 0, 37) // want `'base' must not be larger than 36`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckStrconv_go115/ 0000775 0000000 0000000 00000000000 14143223131 0023671 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckStrconv_go115/CheckStrconv.go 0000664 0000000 0000000 00000001273 14143223131 0026617 0 ustar 00root root 0000000 0000000 // +build go1.15
package pkg
import "strconv"
func fn() {
strconv.ParseComplex("", 32) // want `'bitSize' argument is invalid, must be either 64 or 128`
strconv.ParseComplex("", 64)
strconv.ParseComplex("", 128)
strconv.ParseComplex("", 256) // want `'bitSize' argument is invalid, must be either 64 or 128`
strconv.FormatComplex(0, 'e', 0, 32) // want `'bitSize' argument is invalid, must be either 64 or 128`
strconv.FormatComplex(0, 'e', 0, 64)
strconv.FormatComplex(0, 'e', 0, 128)
strconv.FormatComplex(0, 'e', 0, 256) // want `'bitSize' argument is invalid, must be either 64 or 128`
strconv.FormatComplex(0, 'j', 0, 64) // want `'fmt' argument is invalid: unknown format 'j'`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckStrconv_go115/stub.go 0000664 0000000 0000000 00000000014 14143223131 0025170 0 ustar 00root root 0000000 0000000 package pkg
go-tools-2021.1.2/staticcheck/testdata/src/CheckStringsReplaceZero/ 0000775 0000000 0000000 00000000000 14143223131 0025104 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckStringsReplaceZero/CheckStringsReplaceZero.go 0000664 0000000 0000000 00000000311 14143223131 0032151 0 ustar 00root root 0000000 0000000 package pkg
import "strings"
func fn() {
_ = strings.Replace("", "", "", 0) // want `calling strings\.Replace with n == 0`
_ = strings.Replace("", "", "", -1)
_ = strings.Replace("", "", "", 1)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckStructTags/ 0000775 0000000 0000000 00000000000 14143223131 0023422 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckStructTags/CheckStructTags.go 0000664 0000000 0000000 00000003775 14143223131 0027026 0 ustar 00root root 0000000 0000000 package pkg
import (
"encoding/xml"
_ "github.com/jessevdk/go-flags"
)
type T1 struct {
B int `foo:"" foo:""` // want `duplicate struct tag`
C int `foo:"" bar:""`
D int `json:"-"`
E int `json:"\\"` // want `invalid JSON field name`
F int `json:",omitempty,omitempty"` // want `duplicate JSON option "omitempty"`
G int `json:",omitempty,string"`
H int `json:",string,omitempty,string"` // want `duplicate JSON option "string"`
I int `json:",unknown"` // want `unknown JSON option "unknown"`
J int `json:",string"`
K *int `json:",string"`
L **int `json:",string"` // want `the JSON string option`
M complex128 `json:",string"` // want `the JSON string option`
N int `json:"some-name"`
O int `json:"some-name,inline"`
}
type T2 struct {
A int `xml:",attr"`
B int `xml:",chardata"`
C int `xml:",cdata"`
D int `xml:",innerxml"`
E int `xml:",comment"`
F int `xml:",omitempty"`
G int `xml:",any"`
H int `xml:",unknown"` // want `unknown option`
I int `xml:",any,any"` // want `duplicate option`
J int `xml:"a>b>c,"`
}
type T3 struct {
A int `json:",omitempty" xml:",attr"`
B int `json:",unknown" xml:",attr"` // want `unknown JSON option`
}
type T4 struct {
A int `choice:"foo" choice:"bar"`
B []int `optional-value:"foo" optional-value:"bar"`
C []int `default:"foo" default:"bar"`
D int `json:"foo" json:"bar"` // want `duplicate struct tag`
}
func xmlTags() {
type T1 struct {
A int `xml:",attr,innerxml"` // want `invalid combination of options: ",attr,innerxml"`
XMLName xml.Name `xml:"ns "` // want `namespace without name: "ns "`
B int `xml:"a>"` // want `trailing '>'`
C int `xml:"a>b,attr"` // want `a>b chain not valid with attr flag`
}
type T6 struct {
XMLName xml.Name `xml:"foo"`
}
type T5 struct {
F T6 `xml:"f"` // want `name "f" conflicts with name "foo" in CheckStructTags\.T6\.XMLName`
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckStructTags2/ 0000775 0000000 0000000 00000000000 14143223131 0023504 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckStructTags2/CheckStructTags2.go 0000664 0000000 0000000 00000000434 14143223131 0027157 0 ustar 00root root 0000000 0000000 package pkg
type T5 struct {
A int `choice:"foo" choice:"bar"` // want `duplicate struct tag`
B []int `optional-value:"foo" optional-value:"bar"` // want `duplicate struct tag`
C []int `default:"foo" default:"bar"` // want `duplicate struct tag`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckStructTags3/ 0000775 0000000 0000000 00000000000 14143223131 0023505 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckStructTags3/CheckStructTags.go 0000664 0000000 0000000 00000002710 14143223131 0027075 0 ustar 00root root 0000000 0000000 package pkg
import _ "github.com/jessevdk/go-flags"
type T1 struct {
B int `foo:"" foo:""` // want `duplicate struct tag`
C int `foo:"" bar:""`
D int `json:"-"`
E int `json:"\\"` // want `invalid JSON field name`
F int `json:",omitempty,omitempty"` // want `duplicate JSON option "omitempty"`
G int `json:",omitempty,string"`
H int `json:",string,omitempty,string"` // want `duplicate JSON option "string"`
I int `json:",unknown"` // want `unknown JSON option "unknown"`
J int `json:",string"`
K *int `json:",string"`
L **int `json:",string"` // want `the JSON string option`
M complex128 `json:",string"` // want `the JSON string option`
N int `json:"some-name"`
O int `json:"some-name,inline"`
}
type T2 struct {
A int `xml:",attr"`
B int `xml:",chardata"`
C int `xml:",cdata"`
D int `xml:",innerxml"`
E int `xml:",comment"`
F int `xml:",omitempty"`
G int `xml:",any"`
H int `xml:",unknown"` // want `unknown option`
I int `xml:",any,any"` // want `duplicate option`
J int `xml:"a>b>c,"`
}
type T3 struct {
A int `json:",omitempty" xml:",attr"`
B int `json:",unknown" xml:",attr"` // want `unknown JSON option`
}
type T4 struct {
A int `choice:"foo" choice:"bar"`
B []int `optional-value:"foo" optional-value:"bar"`
C []int `default:"foo" default:"bar"`
D int `json:"foo" json:"bar"` // want `duplicate struct tag`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckStructTags3/vendor/ 0000775 0000000 0000000 00000000000 14143223131 0025002 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckStructTags3/vendor/github.com/ 0000775 0000000 0000000 00000000000 14143223131 0027041 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckStructTags3/vendor/github.com/jessevdk/ 0000775 0000000 0000000 00000000000 14143223131 0030657 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckStructTags3/vendor/github.com/jessevdk/go-flags/ 0000775 0000000 0000000 00000000000 14143223131 0032356 5 ustar 00root root 0000000 0000000 pkg.go 0000664 0000000 0000000 00000000014 14143223131 0033402 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckStructTags3/vendor/github.com/jessevdk/go-flags package pkg
go-tools-2021.1.2/staticcheck/testdata/src/CheckSyncPoolValue/ 0000775 0000000 0000000 00000000000 14143223131 0024062 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckSyncPoolValue/CheckSyncPoolValue.go 0000664 0000000 0000000 00000001570 14143223131 0030115 0 ustar 00root root 0000000 0000000 package pkg
import (
"sync"
"unsafe"
)
type T1 struct {
x int
}
type T2 struct {
x int
y int
}
func fn() {
s := []int{}
v := sync.Pool{}
v.Put(s) // want `argument should be pointer-like`
v.Put(&s)
v.Put(T1{}) // want `argument should be pointer-like`
v.Put(T2{}) // want `argument should be pointer-like`
p := &sync.Pool{}
p.Put(s) // want `argument should be pointer-like`
p.Put(&s)
var i interface{}
p.Put(i)
var up unsafe.Pointer
p.Put(up)
var basic int
p.Put(basic) // want `argument should be pointer-like`
}
func fn2() {
// https://github.com/dominikh/go-tools/issues/873
var pool sync.Pool
func() {
defer pool.Put([]byte{}) // want `argument should be pointer-like`
}()
}
func fn3() {
var pool sync.Pool
defer pool.Put([]byte{}) // want `argument should be pointer-like`
go pool.Put([]byte{}) // want `argument should be pointer-like`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTemplate/ 0000775 0000000 0000000 00000000000 14143223131 0023072 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTemplate/CheckTemplate.go 0000664 0000000 0000000 00000000617 14143223131 0026136 0 ustar 00root root 0000000 0000000 package pkg
import (
th "html/template"
tt "text/template"
)
const tmpl1 = `{{.Name}} {{.LastName}`
const tmpl2 = `{{fn}}`
func fn() {
tt.New("").Parse(tmpl1) // want `template`
tt.New("").Parse(tmpl2)
t1 := tt.New("")
t1.Parse(tmpl1)
th.New("").Parse(tmpl1) // want `template`
th.New("").Parse(tmpl2)
t2 := th.New("")
t2.Parse(tmpl1)
tt.New("").Delims("[[", "]]").Parse("{{abc-}}")
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTestMainExit-1_go115/ 0000775 0000000 0000000 00000000000 14143223131 0024747 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTestMainExit-1_go115/CheckTestMainExit-1.go 0000664 0000000 0000000 00000000110 14143223131 0030740 0 ustar 00root root 0000000 0000000 package pkg
import "testing"
func TestMain(m *testing.M) {
m.Run()
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTestMainExit-1_go14/ 0000775 0000000 0000000 00000000000 14143223131 0024665 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTestMainExit-1_go14/CheckTestMainExit-1.go 0000664 0000000 0000000 00000000147 14143223131 0030670 0 ustar 00root root 0000000 0000000 package pkg
import "testing"
func TestMain(m *testing.M) { // want `should call os\.Exit`
m.Run()
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTestMainExit-2_go14/ 0000775 0000000 0000000 00000000000 14143223131 0024666 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTestMainExit-2_go14/CheckTestMainExit-2.go 0000664 0000000 0000000 00000000137 14143223131 0030671 0 ustar 00root root 0000000 0000000 package pkg
import (
"os"
"testing"
)
func TestMain(m *testing.M) {
m.Run()
os.Exit(1)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTestMainExit-3_go14/ 0000775 0000000 0000000 00000000000 14143223131 0024667 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTestMainExit-3_go14/CheckTestMainExit-3.go 0000664 0000000 0000000 00000000077 14143223131 0030676 0 ustar 00root root 0000000 0000000 package pkg
import "testing"
func TestMain(t *testing.T) {
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTestMainExit-4_go14/ 0000775 0000000 0000000 00000000000 14143223131 0024670 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTestMainExit-4_go14/CheckTestMainExit-4.go 0000664 0000000 0000000 00000000310 14143223131 0030666 0 ustar 00root root 0000000 0000000 package pkg
import (
"os"
"testing"
)
func helper() { os.Exit(1) }
func TestMain(m *testing.M) { // want `should call os\.Exit`
// FIXME(dominikh): this is a false positive
m.Run()
helper()
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTestMainExit-5_go14/ 0000775 0000000 0000000 00000000000 14143223131 0024671 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTestMainExit-5_go14/CheckTestMainExit-5.go 0000664 0000000 0000000 00000000205 14143223131 0030673 0 ustar 00root root 0000000 0000000 package pkg
import (
"os"
"testing"
)
func helper(m *testing.M) { os.Exit(m.Run()) }
func TestMain(m *testing.M) {
helper(m)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTimeParse/ 0000775 0000000 0000000 00000000000 14143223131 0023210 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTimeParse/CheckTimeParse.go 0000664 0000000 0000000 00000000404 14143223131 0026364 0 ustar 00root root 0000000 0000000 package pkg
import "time"
const c1 = "12345"
const c2 = "2006"
func fn() {
time.Parse("12345", "") // want `parsing time`
time.Parse(c1, "") // want `parsing time`
time.Parse(c2, "")
time.Parse(time.RFC3339Nano, "")
time.Parse(time.Kitchen, "")
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTimeSleepConstant/ 0000775 0000000 0000000 00000000000 14143223131 0024720 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTimeSleepConstant/CheckTimeSleepConstant.go 0000664 0000000 0000000 00000000411 14143223131 0031602 0 ustar 00root root 0000000 0000000 package pkg
import "time"
const c1 = 1
const c2 = 200
func fn() {
time.Sleep(1) // want `sleeping for 1`
time.Sleep(42) // want `sleeping for 42`
time.Sleep(201)
time.Sleep(c1)
time.Sleep(c2)
time.Sleep(2 * time.Nanosecond)
time.Sleep(time.Nanosecond)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTimeSleepConstant/CheckTimeSleepConstant.go.golden 0000664 0000000 0000000 00000001206 14143223131 0033054 0 ustar 00root root 0000000 0000000 -- explicitly use nanoseconds --
package pkg
import "time"
const c1 = 1
const c2 = 200
func fn() {
time.Sleep(1 * time.Nanosecond) // want `sleeping for 1`
time.Sleep(42 * time.Nanosecond) // want `sleeping for 42`
time.Sleep(201)
time.Sleep(c1)
time.Sleep(c2)
time.Sleep(2 * time.Nanosecond)
time.Sleep(time.Nanosecond)
}
-- use seconds --
package pkg
import "time"
const c1 = 1
const c2 = 200
func fn() {
time.Sleep(1 * time.Second) // want `sleeping for 1`
time.Sleep(42 * time.Second) // want `sleeping for 42`
time.Sleep(201)
time.Sleep(c1)
time.Sleep(c2)
time.Sleep(2 * time.Nanosecond)
time.Sleep(time.Nanosecond)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTimerResetReturnValue/ 0000775 0000000 0000000 00000000000 14143223131 0025577 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTimerResetReturnValue/CheckTimerResetReturnValue.go 0000664 0000000 0000000 00000002540 14143223131 0033345 0 ustar 00root root 0000000 0000000 package fn
import "time"
func fn1() {
t := time.NewTimer(time.Second)
t.Reset(time.Second)
}
func fn2() {
t := time.NewTimer(time.Second)
_ = t.Reset(time.Second)
}
func fn3() {
t := time.NewTimer(time.Second)
println(t.Reset(time.Second))
}
func fn4() {
t := time.NewTimer(time.Second)
if t.Reset(time.Second) {
println("x")
}
}
func fn5() {
t := time.NewTimer(time.Second)
if t.Reset(time.Second) { // want `it is not possible to use Reset's return value correctly`
<-t.C
}
}
func fn6(x bool) {
// Not matched because we don't support complex boolean
// expressions
t := time.NewTimer(time.Second)
if t.Reset(time.Second) || x {
<-t.C
}
}
func fn7(x bool) {
// Not matched because we don't analyze that deeply
t := time.NewTimer(time.Second)
y := t.Reset(2 * time.Second)
z := x || y
println(z)
if z {
<-t.C
}
}
func fn8() {
t := time.NewTimer(time.Second)
abc := t.Reset(time.Second) // want `it is not possible to use Reset's return value correctly`
if abc {
<-t.C
}
}
func fn9() {
t := time.NewTimer(time.Second)
if t.Reset(time.Second) {
println("x")
}
<-t.C
}
func fn10() {
t := time.NewTimer(time.Second)
if !t.Reset(time.Second) { // want `it is not possible to use Reset's return value correctly`
<-t.C
}
}
func fn11(ch chan int) {
t := time.NewTimer(time.Second)
if !t.Reset(time.Second) {
<-ch
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckToLowerToUpperComparison/ 0000775 0000000 0000000 00000000000 14143223131 0026264 5 ustar 00root root 0000000 0000000 CheckToLowerToUpperComparison.go 0000664 0000000 0000000 00000001562 14143223131 0034443 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckToLowerToUpperComparison package pkg
import "strings"
func fn() {
const (
s1 = "foo"
s2 = "bar"
)
if strings.ToLower(s1) == strings.ToLower(s2) { // want `should use strings\.EqualFold instead`
panic("")
}
if strings.ToUpper(s1) == strings.ToUpper(s2) { // want `should use strings\.EqualFold instead`
panic("")
}
if strings.ToLower(s1) != strings.ToLower(s2) { // want `should use strings\.EqualFold instead`
panic("")
}
switch strings.ToLower(s1) == strings.ToLower(s2) { // want `should use strings\.EqualFold instead`
case true, false:
panic("")
}
if strings.ToLower(s1) == strings.ToLower(s2) || s1+s2 == s2+s1 { // want `should use strings\.EqualFold instead`
panic("")
}
if strings.ToLower(s1) > strings.ToLower(s2) {
panic("")
}
if strings.ToLower(s1) < strings.ToLower(s2) {
panic("")
}
if strings.ToLower(s1) == strings.ToUpper(s2) {
panic("")
}
}
CheckToLowerToUpperComparison.go.golden 0000664 0000000 0000000 00000001436 14143223131 0035712 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckToLowerToUpperComparison package pkg
import "strings"
func fn() {
const (
s1 = "foo"
s2 = "bar"
)
if strings.EqualFold(s1, s2) { // want `should use strings\.EqualFold instead`
panic("")
}
if strings.EqualFold(s1, s2) { // want `should use strings\.EqualFold instead`
panic("")
}
if !strings.EqualFold(s1, s2) { // want `should use strings\.EqualFold instead`
panic("")
}
switch strings.EqualFold(s1, s2) { // want `should use strings\.EqualFold instead`
case true, false:
panic("")
}
if strings.EqualFold(s1, s2) || s1+s2 == s2+s1 { // want `should use strings\.EqualFold instead`
panic("")
}
if strings.ToLower(s1) > strings.ToLower(s2) {
panic("")
}
if strings.ToLower(s1) < strings.ToLower(s2) {
panic("")
}
if strings.ToLower(s1) == strings.ToUpper(s2) {
panic("")
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/ 0000775 0000000 0000000 00000000000 14143223131 0024670 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/CheckTypedNilInterface.go 0000664 0000000 0000000 00000006656 14143223131 0031543 0 ustar 00root root 0000000 0000000 package pkg
import (
"errors"
"os/exec"
)
type T struct{ x *int }
func fn1() *int { return nil }
func fn2() (int, *int, int) { return 0, nil, 0 }
func fn3() (int, error) { return 0, nil }
func fn4() error { return nil }
func gen1() interface{} {
// don't flag, returning a concrete value
return 0
}
func gen2() interface{} {
// don't flag, returning a concrete value
return &T{}
}
func gen3() interface{} {
// flag, always returns a typed value
m := map[int]*int{}
return m[0]
}
func gen4() (int, interface{}, *int) {
// flag ret[1], always a typed value
m := map[int]*int{}
return 0, m[0], nil
}
func gen5() interface{} {
// 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() interface{} {
// flag, always returns a typed value
return fn1()
}
func gen8(x *int) interface{} {
// flag
if x == nil {
return x
}
return x
}
func gen9() interface{} {
// flag
var x *int
return x
}
func gen10() interface{} {
// flag
var x *int
if x == nil {
return x
}
return errors.New("")
// This is a tricky one. we should flag this, because it never
// returns a nil error, but if errors.New could return untyped
// nils, then we shouldn't flag it. we need to consider the
// implementation of the called function.
}
func gen11() interface{} {
// don't flag, we sometimes return untyped nil
if true {
return nil
} else {
return (*int)(nil)
}
}
func gen12(b bool) interface{} {
// flag, all branches return typed nils
var x interface{}
if b {
x = (*int)(nil)
} else {
x = (*string)(nil)
}
return x
}
func gen13() interface{} {
// flag, always returns a typed value
_, x, _ := fn2()
return x
}
func gen14(ch chan *int) interface{} {
// flag
return <-ch
}
func gen15() interface{} {
// flag
t := &T{}
return t.x
}
var g *int = new(int)
func gen16() interface{} {
// don't flag. returning a global is akin to returning &T{}.
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{} {
if true {
return g
}
return (*int)(nil)
}
func test() {
_ = gen1() == nil
_ = gen2() == nil
_ = gen3() == nil // want `never true`
{
_, r2, r3 := gen4()
_ = r2 == nil // want `never true`
_ = r3 == nil
}
_ = gen5() == nil // want `never true`
_ = gen6(false) == nil
_ = gen7() == nil // want `never true`
_ = gen8(nil) == nil // want `never true`
_ = gen9() == nil // want `never true`
_ = gen10() == nil // want `never true`
_ = gen11() == nil
_ = gen12(true) == nil // want `never true`
_ = gen13() == nil // want `never true`
_ = gen14(nil) == nil // want `never true`
_ = gen15() == nil // want `never true`
_ = gen16() == nil
_ = gen17(nil) == nil
{
_, r2 := gen18()
_ = r2 == nil
}
_ = gen19() == nil
_ = gen20() == nil
_ = gen21() == nil
_ = gen22() == nil // want `never true`
var v1 interface{} = 0
_ = v1 == nil // want `never true; the lhs`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/i26000/ 0000775 0000000 0000000 00000000000 14143223131 0025510 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/i26000/26000.go 0000664 0000000 0000000 00000001002 14143223131 0026477 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
)
type CustomError struct {
Err string
}
func (ce CustomError) Error() string {
return ce.Err
}
func SomeFunc() (string, *CustomError) {
return "hello", nil
}
func main() {
// Do something that creates a variable err of type error
_, err := os.Open("/")
if err != nil {
panic(err)
}
// Then replace the err type with *CustomError
val, err := SomeFunc()
if err != nil { // want `this comparison is always true`
panic(err)
}
fmt.Println("No problem", val)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/i27815/ 0000775 0000000 0000000 00000000000 14143223131 0025527 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/i27815/27815.go 0000664 0000000 0000000 00000000510 14143223131 0026540 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
)
type MyError struct {
x string
}
func (e *MyError) Error() string {
return e.x
}
func f() *MyError {
return nil
}
func main() {
var e error
e = f()
// e should be nil ?
if e != nil { // want `this comparison is always true`
fmt.Println("NOT NIL")
} else {
fmt.Println("NIL")
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/i28241/ 0000775 0000000 0000000 00000000000 14143223131 0025521 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/i28241/28241.go 0000664 0000000 0000000 00000001066 14143223131 0026533 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"reflect"
)
type Nil interface {
String() string
}
func MakeNil() Nil {
var n *NilStruct
return n
}
type NilStruct struct {
Data string
}
func (n *NilStruct) String() string {
return n.Data
}
func main() {
var n *NilStruct
fmt.Printf("%t %#v %s %t\n",
n == nil,
n,
reflect.ValueOf(n).Kind(),
reflect.ValueOf(n).IsNil())
n2 := MakeNil()
fmt.Printf("%t %#v %s %t\n",
n2 == nil, // want `this comparison is never true`
n2,
reflect.ValueOf(n2).Kind(),
reflect.ValueOf(n2).IsNil())
fmt.Println(n2.String())
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/i31873/ 0000775 0000000 0000000 00000000000 14143223131 0025526 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/i31873/31873.go 0000664 0000000 0000000 00000000553 14143223131 0026545 0 ustar 00root root 0000000 0000000 package main
import "fmt"
type S struct{}
func (s *S) Error() string {
return "error for S"
}
func structNil() *S {
return nil
}
func errorNil() error {
return nil
}
func main() {
err := errorNil()
fmt.Println(err != nil)
err = structNil()
fmt.Println(err != nil) // want `this comparison is always true`
err = errorNil()
fmt.Println(err != nil)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/i33965/ 0000775 0000000 0000000 00000000000 14143223131 0025532 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/i33965/33965.go 0000664 0000000 0000000 00000000651 14143223131 0026554 0 ustar 00root root 0000000 0000000 package pkg
import (
"fmt"
"testing"
)
type customError struct {
}
func (p *customError) Error() string {
return "custom error"
}
func getNilCustomError() *customError {
return nil
}
func TestWebSocketClient_basic(t *testing.T) {
err1 := getNilCustomError()
fmt.Println(err1 == nil) // ok is true
err2 := error(nil)
err2 = getNilCustomError()
fmt.Println(err2 == nil) // want `this comparison is never true`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/i33994/ 0000775 0000000 0000000 00000000000 14143223131 0025534 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/i33994/33994.go 0000664 0000000 0000000 00000000741 14143223131 0026560 0 ustar 00root root 0000000 0000000 package main
import (
"errors"
"fmt"
)
func main() {
var err = errors.New("errors msg")
name, err := GetName()
if err != nil { // want `this comparison is always true`
fmt.Println(err)
} else {
fmt.Println(name)
}
}
type Error struct {
Message string
}
func (e *Error) Error() string {
if e == nil {
return "Error is nil"
}
return e.Message
}
func GetName() (string, *Error) {
var err = &Error{
Message: "error msg",
}
err = nil
return "yixinin", err
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/i35217/ 0000775 0000000 0000000 00000000000 14143223131 0025522 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/i35217/35217.go 0000664 0000000 0000000 00000000540 14143223131 0026531 0 ustar 00root root 0000000 0000000 package main
import (
"errors"
"fmt"
)
type someError struct {
Msg string
}
func (e *someError) Error() string {
return "someError: " + e.Msg
}
func calculate() (int, *someError) {
return 42, nil
}
func main() {
err := errors.New("ERROR")
num, err := calculate()
fmt.Println(num, err, err == nil) // want `this comparison is never true`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckTypedNilInterface/real.go 0000664 0000000 0000000 00000001267 14143223131 0026150 0 ustar 00root root 0000000 0000000 package pkg
import "log"
type iface interface{ m() }
type t1 struct{ int }
func (t *t1) m() { log.Println(t.int) }
type internalMessage struct{ v *t1 }
func f(msg chan internalMessage, input int) {
k := &t1{input}
if input > 2 {
k = nil
}
msg <- internalMessage{k}
}
func SyncPublicMethod(input int) iface {
ch := make(chan internalMessage)
go f(ch, input)
answer := <-ch
// Problem: if answer.v == nil then this will created typed nil iface return value
return answer.v
}
func main() {
for i := 0; i < 10; i++ {
k := SyncPublicMethod(i)
if k == nil { // want `this comparison is never true`
log.Println("never printed")
return
}
// Will panic.
k.m()
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckURLs/ 0000775 0000000 0000000 00000000000 14143223131 0022144 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckURLs/CheckURLs.go 0000664 0000000 0000000 00000000220 14143223131 0024250 0 ustar 00root root 0000000 0000000 package pkg
import "net/url"
func fn() {
url.Parse("foobar")
url.Parse(":") // want `is not a valid URL`
url.Parse("https://golang.org")
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckUnbufferedSignalChan/ 0000775 0000000 0000000 00000000000 14143223131 0025334 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckUnbufferedSignalChan/CheckUnbufferedSignalChan.go 0000664 0000000 0000000 00000000554 14143223131 0032642 0 ustar 00root root 0000000 0000000 package pkg
import (
"os"
"os/signal"
"syscall"
)
func fn(b bool) {
c0 := make(chan os.Signal)
signal.Notify(c0, os.Interrupt) // want `the channel used with signal\.Notify should be buffered`
c1 := make(chan os.Signal, 1)
signal.Notify(c1, os.Interrupt, syscall.SIGHUP)
c2 := c0
if b {
c2 = c1
}
signal.Notify(c2, os.Interrupt, syscall.SIGHUP)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckUnmarshalPointer/ 0000775 0000000 0000000 00000000000 14143223131 0024612 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckUnmarshalPointer/CheckUnmarshalPointer.go 0000664 0000000 0000000 00000001052 14143223131 0031370 0 ustar 00root root 0000000 0000000 package pkg
import "encoding/json"
func fn1(i3 interface{}) {
var v map[string]interface{}
var i1 interface{} = v
var i2 interface{} = &v
p := &v
json.Unmarshal([]byte(`{}`), v) // want `Unmarshal expects to unmarshal into a pointer`
json.Unmarshal([]byte(`{}`), &v)
json.Unmarshal([]byte(`{}`), i1) // want `Unmarshal expects to unmarshal into a pointer`
json.Unmarshal([]byte(`{}`), i2)
json.Unmarshal([]byte(`{}`), i3)
json.Unmarshal([]byte(`{}`), p)
json.NewDecoder(nil).Decode(v) // want `Decode expects to unmarshal into a pointer`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckUnreachableTypeCases/ 0000775 0000000 0000000 00000000000 14143223131 0025351 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckUnreachableTypeCases/CheckUnreachableTypeCases.go 0000664 0000000 0000000 00000005423 14143223131 0032674 0 ustar 00root root 0000000 0000000 package pkg
import "io"
type T struct{}
func (T) Read(b []byte) (int, error) { return 0, nil }
func (T) something() string { return "non-exported method" }
type V error
type U error
func fn1() {
var (
v interface{}
err error
)
switch v.(type) {
case io.Reader:
println("io.Reader")
case io.ReadCloser: // want `unreachable case clause: io\.Reader will always match before io\.ReadCloser`
println("io.ReadCloser")
}
switch v.(type) {
case io.Reader:
println("io.Reader")
case T: // want `unreachable case clause: io\.Reader will always match before CheckUnreachableTypeCases\.T`
println("T")
}
switch v.(type) {
case io.Reader:
println("io.Reader")
case io.ReadCloser: // want `unreachable case clause: io\.Reader will always match before io\.ReadCloser`
println("io.ReadCloser")
case T: // want `unreachable case clause: io\.Reader will always match before CheckUnreachableTypeCases\.T`
println("T")
}
switch v.(type) {
case io.Reader:
println("io.Reader")
case io.ReadCloser, T: // want `unreachable case clause: io\.Reader will always match before io\.ReadCloser`
println("io.ReadCloser or T")
}
switch v.(type) {
case io.ReadCloser, io.Reader:
println("io.ReadCloser or io.Reader")
case T: // want `unreachable case clause: io\.Reader will always match before CheckUnreachableTypeCases\.T`
println("T")
}
switch v.(type) {
default:
println("something else")
case io.Reader:
println("io.Reader")
case T: // want `unreachable case clause: io\.Reader will always match before CheckUnreachableTypeCases\.T`
println("T")
}
switch v.(type) {
case interface{}:
println("interface{}")
case nil, T: // want `unreachable case clause: interface{} will always match before CheckUnreachableTypeCases\.T`
println("nil or T")
}
switch err.(type) {
case V:
println("V")
case U: // want `unreachable case clause: CheckUnreachableTypeCases\.V will always match before CheckUnreachableTypeCases\.U`
println("U")
}
switch err.(type) {
case U:
println("U")
case V: // want `unreachable case clause: CheckUnreachableTypeCases\.U will always match before CheckUnreachableTypeCases\.V`
println("V")
}
}
func fn3() {
var (
v interface{}
err error
)
switch v.(type) {
case T:
println("T")
case io.Reader:
println("io.Reader")
}
switch v.(type) {
case io.ReadCloser:
println("io.ReadCloser")
case T:
println("T")
}
switch v.(type) {
case io.ReadCloser:
println("io.ReadCloser")
case io.Reader:
println("io.Reader")
}
switch v.(type) {
case T:
println("T")
}
switch err.(type) {
case V, U:
println("V or U")
case io.Reader:
println("io.Reader")
}
switch v.(type) {
default:
println("something")
}
switch v.(type) {
case interface{}:
println("interface{}")
case nil:
println("nil")
}
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckUnreadVariableValues/ 0000775 0000000 0000000 00000000000 14143223131 0025363 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckUnreadVariableValues/CheckUnreadVariableValues.go 0000664 0000000 0000000 00000004307 14143223131 0032720 0 ustar 00root root 0000000 0000000 package pkg
import "fmt"
func fn1() {
var x int
x = gen() // want `this value of x is never used`
x = gen()
println(x)
var y int
if true {
y = gen() // want `this value of y is never used`
}
y = gen()
println(y)
}
func gen() int {
println() // make it unpure
return 0
}
func fn2() {
x, y := gen(), gen() // want `this value of x is never used` `this value of y is never used`
x, y = gen(), gen()
println(x, y)
}
func fn3() {
x := uint32(0)
if true {
x = 1
} else {
x = 2
}
println(x)
}
func gen2() (int, int) {
println()
return 0, 0
}
func fn4() {
x, y := gen2() // want `this value of x is never used`
println(y)
x, y = gen2() // want `this value of x is never used` `this value of y is never used`
x, _ = gen2() // want `this value of x is never used`
x, y = gen2()
println(x, y)
}
func fn5(m map[string]string) {
v, ok := m[""] // want `this value of v is never used` `this value of ok is never used`
v, ok = m[""]
println(v, ok)
}
func fn6() {
x := gen()
// Do not report variables if they've been assigned to the blank identifier
_ = x
}
func fn7() {
func() {
var x int
x = gen() // want `this value of x is never used`
x = gen()
println(x)
}()
}
func fn() int { println(); return 0 }
var y = func() {
v := fn() // want `never used`
v = fn()
println(v)
}
func fn8() {
x := gen()
switch x {
}
y := gen() // want `this value of y is never used`
y = gen()
switch y {
}
z, _ := gen2()
switch z {
}
_, a := gen2()
switch a {
}
b, c := gen2() // want `this value of b is never used`
println(c)
b, c = gen2() // want `this value of c is never used`
switch b {
}
}
func fn9() {
xs := []int{}
for _, x := range xs {
foo, err := work(x) // want `this value of foo is never used`
if err != nil {
return
}
if !foo {
continue
}
}
}
func work(int) (bool, error) { return false, nil }
func resolveWeakTypes(types []int) {
for i := range types {
runEnd := findRunLimit(i)
if true {
_ = runEnd
}
i = runEnd // want `this value of i is never used`
}
}
func findRunLimit(int) int { return 0 }
func fn10() {
slice := []string(nil)
if true {
slice = []string{"1", "2"}
} else {
slice = []string{"3", "4"}
}
fmt.Println(slice)
}
CheckUnreadVariableValues_test.go 0000664 0000000 0000000 00000000254 14143223131 0033675 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckUnreadVariableValues package pkg
import "testing"
func TestFoo(t *testing.T) {
x := fn() // want `never used`
x = fn()
println(x)
}
func ExampleFoo() {
x := fn()
x = fn()
println(x)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckUnsafePrintf/ 0000775 0000000 0000000 00000000000 14143223131 0023723 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckUnsafePrintf/CheckUnsafePrintf.go 0000664 0000000 0000000 00000001142 14143223131 0027612 0 ustar 00root root 0000000 0000000 package pkg
import (
"fmt"
"log"
"os"
)
func fn(s string) {
fn2 := func() string { return "" }
fmt.Printf(fn2()) // want `should use print-style function`
_ = fmt.Sprintf(fn2()) // want `should use print-style function`
log.Printf(fn2()) // want `should use print-style function`
fmt.Printf(s) // want `should use print-style function`
fmt.Printf(s, "")
fmt.Fprintf(os.Stdout, s) // want `should use print-style function`
fmt.Fprintf(os.Stdout, s, "")
fmt.Printf(fn2(), "")
fmt.Printf("")
fmt.Printf("%s", "")
fmt.Printf(fn3())
}
func fn3() (string, int) { return "", 0 }
go-tools-2021.1.2/staticcheck/testdata/src/CheckUnsafePrintf/CheckUnsafePrintf.go.golden 0000664 0000000 0000000 00000001135 14143223131 0031063 0 ustar 00root root 0000000 0000000 package pkg
import (
"fmt"
"log"
"os"
)
func fn(s string) {
fn2 := func() string { return "" }
fmt.Print(fn2()) // want `should use print-style function`
_ = fmt.Sprint(fn2()) // want `should use print-style function`
log.Print(fn2()) // want `should use print-style function`
fmt.Print(s) // want `should use print-style function`
fmt.Printf(s, "")
fmt.Fprint(os.Stdout, s) // want `should use print-style function`
fmt.Fprintf(os.Stdout, s, "")
fmt.Printf(fn2(), "")
fmt.Printf("")
fmt.Printf("%s", "")
fmt.Printf(fn3())
}
func fn3() (string, int) { return "", 0 }
go-tools-2021.1.2/staticcheck/testdata/src/CheckUnsupportedMarshal/ 0000775 0000000 0000000 00000000000 14143223131 0025157 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckUnsupportedMarshal/CheckUnsupportedMarshal.go 0000664 0000000 0000000 00000015031 14143223131 0032304 0 ustar 00root root 0000000 0000000 package pkg
import (
"encoding/json"
"encoding/xml"
"time"
)
type T1 struct {
A int
B func() `json:"-" xml:"-"`
c chan int
}
type T2 struct {
T1
}
type T3 struct {
Ch chan int
}
type T4 struct {
C ValueMarshaler
}
type T5 struct {
B func() `xml:"-"`
}
type T6 struct {
B func() `json:"-"`
}
type T7 struct {
A int
B int
T3
}
type T8 struct {
C int
*T7
}
type T9 struct {
F PointerMarshaler
}
type T10 struct {
F *struct {
PointerMarshaler
}
}
type Recursive struct {
Field *Recursive
}
type ValueMarshaler chan int
func (ValueMarshaler) MarshalText() ([]byte, error) { return nil, nil }
type PointerMarshaler chan int
func (*PointerMarshaler) MarshalText() ([]byte, error) { return nil, nil }
func fn() {
var t1 T1
var t2 T2
var t3 T3
var t4 T4
var t5 T5
var t6 T6
var t8 T8
var t9 T9
var t10 T10
var t11 Recursive
json.Marshal(t1)
json.Marshal(t2)
json.Marshal(t3) // want `unsupported type chan int, via x\.Ch`
json.Marshal(t4)
json.Marshal(t5) // want `unsupported type func\(\), via x\.B`
json.Marshal(t6)
(*json.Encoder)(nil).Encode(t1)
(*json.Encoder)(nil).Encode(t2)
(*json.Encoder)(nil).Encode(t3) // want `unsupported type chan int, via x\.Ch`
(*json.Encoder)(nil).Encode(t4)
(*json.Encoder)(nil).Encode(t5) // want `unsupported type func\(\), via x\.B`
(*json.Encoder)(nil).Encode(t6)
xml.Marshal(t1)
xml.Marshal(t2)
xml.Marshal(t3) // want `unsupported type chan int, via x\.Ch`
xml.Marshal(t4)
xml.Marshal(t5)
xml.Marshal(t6) // want `unsupported type func\(\), via x\.B`
(*xml.Encoder)(nil).Encode(t1)
(*xml.Encoder)(nil).Encode(t2)
(*xml.Encoder)(nil).Encode(t3) // want `unsupported type chan int, via x\.C`
(*xml.Encoder)(nil).Encode(t4)
(*xml.Encoder)(nil).Encode(t5)
(*xml.Encoder)(nil).Encode(t6) // want `unsupported type func\(\), via x\.B`
json.Marshal(t8) // want `unsupported type chan int, via x\.T7\.T3\.Ch`
json.Marshal(t9) // want `unsupported type PointerMarshaler, via x\.F`
json.Marshal(&t9) // this is fine, t9 is addressable, therefore T9.D is, too
json.Marshal(t10) // this is fine, T10.F.D is addressable
xml.Marshal(t8) // want `unsupported type chan int, via x\.T7\.T3\.Ch`
xml.Marshal(t9) // want `unsupported type PointerMarshaler, via x\.F`
xml.Marshal(&t9) // this is fine, t9 is addressable, therefore T9.D is, too
xml.Marshal(t10) // this is fine, T10.F.D is addressable
json.Marshal(t11)
xml.Marshal(t11)
}
func addressabilityJSON() {
var a PointerMarshaler
var b []PointerMarshaler
var c struct {
F PointerMarshaler
}
var d [4]PointerMarshaler
json.Marshal(a) // want `unsupported type PointerMarshaler$`
json.Marshal(&a)
json.Marshal(b)
json.Marshal(&b)
json.Marshal(c) // want `unsupported type PointerMarshaler, via x\.F`
json.Marshal(&c)
json.Marshal(d) // want `unsupported type PointerMarshaler, via x\[0\]`
json.Marshal(&d)
var m1 map[string]PointerMarshaler
json.Marshal(m1) // want `unsupported type PointerMarshaler, via x\[k\]`
json.Marshal(&m1) // want `unsupported type PointerMarshaler, via x\[k\]`
json.Marshal([]map[string]PointerMarshaler{m1}) // want `unsupported type PointerMarshaler, via x\[0\]\[k\]`
var m2 map[string]*PointerMarshaler
json.Marshal(m2)
json.Marshal(&m2)
json.Marshal([]map[string]*PointerMarshaler{m2})
}
func addressabilityXML() {
var a PointerMarshaler
var b []PointerMarshaler
var c struct {
XMLName xml.Name `json:"foo"`
F PointerMarshaler
}
var d [4]PointerMarshaler
xml.Marshal(a) // want `unsupported type PointerMarshaler$`
xml.Marshal(&a)
xml.Marshal(b)
xml.Marshal(&b)
xml.Marshal(c) // want `unsupported type PointerMarshaler, via x\.F`
xml.Marshal(&c)
xml.Marshal(d) // want `unsupported type PointerMarshaler, via x\[0\]`
xml.Marshal(&d)
}
func mapsJSON() {
var good map[int]string
var bad map[interface{}]string
// the map key has to be statically known good; it must be a number or a string
json.Marshal(good)
json.Marshal(bad) // want `unsupported type map\[interface\{\}\]string$`
var m1 map[string]PointerMarshaler
json.Marshal(m1) // want `unsupported type PointerMarshaler, via x\[k\]`
json.Marshal(&m1) // want `unsupported type PointerMarshaler, via x\[k\]`
json.Marshal([]map[string]PointerMarshaler{m1}) // want `unsupported type PointerMarshaler, via x\[0\]\[k\]`
var m2 map[string]*PointerMarshaler
json.Marshal(m2)
json.Marshal(&m2)
json.Marshal([]map[string]*PointerMarshaler{m2})
var m3 map[string]ValueMarshaler
json.Marshal(m3)
json.Marshal(&m3)
json.Marshal([]map[string]ValueMarshaler{m3})
var m4 map[string]*ValueMarshaler
json.Marshal(m4)
json.Marshal(&m4)
json.Marshal([]map[string]*ValueMarshaler{m4})
var m5 map[ValueMarshaler]string
var m6 map[*ValueMarshaler]string
var m7 map[PointerMarshaler]string
var m8 map[*PointerMarshaler]string
json.Marshal(m5)
json.Marshal(m6)
json.Marshal(m7) // want `unsupported type map\[PointerMarshaler\]string$`
json.Marshal(m8)
}
func mapsXML() {
// encoding/xml doesn't support any maps
var bad map[string]string
xml.Marshal(bad) // want `unsupported type`
}
func fieldPriorityJSON() {
// In this example, the channel doesn't matter, because T1.F has higher priority than T1.T2.F
type lT2 struct {
F chan int
}
type lT1 struct {
F int
lT2
}
json.Marshal(lT1{})
// In this example, it does matter
type lT4 struct {
C chan int
}
type lT3 struct {
F int
lT4
}
json.Marshal(lT3{}) // want `unsupported type chan int, via x\.lT4\.C`
}
func fieldPriorityXML() {
// In this example, the channel doesn't matter, because T1.F has higher priority than T1.T2.F
type lT2 struct {
F chan int
}
type lT1 struct {
F int
lT2
}
xml.Marshal(lT1{})
// In this example, it does matter
type lT4 struct {
C chan int
}
type lT3 struct {
F int
lT4
}
xml.Marshal(lT3{}) // want `unsupported type chan int, via x\.lT4\.C`
}
func longPathJSON() {
var foo struct {
Field struct {
Field2 []struct {
Map map[string]chan int
}
}
}
json.Marshal(foo) // want `unsupported type chan int, via x\.Field\.Field2\[0\].Map\[k\]`
}
func otherPackageJSON() {
var x time.Ticker
json.Marshal(x) // want `unsupported type <-chan time\.Time, via x\.C`
}
func longPathXML() {
var foo struct {
Field struct {
Field2 []struct {
Map map[string]chan int
}
}
}
xml.Marshal(foo) // want `unsupported type map\[string\]chan int, via x\.Field\.Field2\[0\].Map`
}
func otherPackageXML() {
var x time.Ticker
xml.Marshal(x) // want `unsupported type <-chan time\.Time, via x\.C`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckUntrappableSignal/ 0000775 0000000 0000000 00000000000 14143223131 0024732 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckUntrappableSignal/CheckUntrappableSignal.go 0000664 0000000 0000000 00000001165 14143223131 0031635 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"os/signal"
"syscall"
)
func fn() {
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
signal.Ignore(os.Signal(syscall.SIGKILL)) // want `cannot be trapped`
signal.Ignore(os.Kill) // want `cannot be trapped`
signal.Notify(c, os.Kill) // want `cannot be trapped`
signal.Reset(os.Kill) // want `cannot be trapped`
signal.Ignore(syscall.SIGKILL) // want `cannot be trapped`
signal.Notify(c, syscall.SIGKILL) // want `cannot be trapped`
signal.Reset(syscall.SIGKILL) // want `cannot be trapped`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckUntrappableSignal/CheckUntrappableSignal.go.golden 0000664 0000000 0000000 00000004761 14143223131 0033111 0 ustar 00root root 0000000 0000000 -- remove syscall.SIGKILL from list of arguments --
package main
import (
"os"
"os/signal"
"syscall"
)
func fn() {
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
signal.Ignore() // want `cannot be trapped`
signal.Ignore(os.Kill) // want `cannot be trapped`
signal.Notify(c, os.Kill) // want `cannot be trapped`
signal.Reset(os.Kill) // want `cannot be trapped`
signal.Ignore() // want `cannot be trapped`
signal.Notify(c) // want `cannot be trapped`
signal.Reset() // want `cannot be trapped`
}
-- remove os.Kill from list of arguments --
package main
import (
"os"
"os/signal"
"syscall"
)
func fn() {
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
signal.Ignore(os.Signal(syscall.SIGKILL)) // want `cannot be trapped`
signal.Ignore() // want `cannot be trapped`
signal.Notify(c) // want `cannot be trapped`
signal.Reset() // want `cannot be trapped`
signal.Ignore(syscall.SIGKILL) // want `cannot be trapped`
signal.Notify(c, syscall.SIGKILL) // want `cannot be trapped`
signal.Reset(syscall.SIGKILL) // want `cannot be trapped`
}
-- use syscall.SIGTERM instead of syscall.SIGKILL --
package main
import (
"os"
"os/signal"
"syscall"
)
func fn() {
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
signal.Ignore(syscall.SIGTERM) // want `cannot be trapped`
signal.Ignore(os.Kill) // want `cannot be trapped`
signal.Notify(c, os.Kill) // want `cannot be trapped`
signal.Reset(os.Kill) // want `cannot be trapped`
signal.Ignore(syscall.SIGTERM) // want `cannot be trapped`
signal.Notify(c, syscall.SIGTERM) // want `cannot be trapped`
signal.Reset(syscall.SIGTERM) // want `cannot be trapped`
}
-- use syscall.SIGTERM instead of os.Kill --
package main
import (
"os"
"os/signal"
"syscall"
)
func fn() {
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
signal.Ignore(os.Signal(syscall.SIGKILL)) // want `cannot be trapped`
signal.Ignore(syscall.SIGTERM) // want `cannot be trapped`
signal.Notify(c, syscall.SIGTERM) // want `cannot be trapped`
signal.Reset(syscall.SIGTERM) // want `cannot be trapped`
signal.Ignore(syscall.SIGKILL) // want `cannot be trapped`
signal.Notify(c, syscall.SIGKILL) // want `cannot be trapped`
signal.Reset(syscall.SIGKILL) // want `cannot be trapped`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckUntrappableSignal/CheckUntrappableSignal_unix.go 0000664 0000000 0000000 00000000711 14143223131 0032674 0 ustar 00root root 0000000 0000000 //go:build android || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
// +build android darwin dragonfly freebsd linux netbsd openbsd solaris
package main
import (
"os"
"os/signal"
"syscall"
)
func fn2() {
c := make(chan os.Signal, 1)
signal.Ignore(syscall.SIGSTOP) // want `cannot be trapped`
signal.Notify(c, syscall.SIGSTOP) // want `cannot be trapped`
signal.Reset(syscall.SIGSTOP) // want `cannot be trapped`
}
CheckUntrappableSignal_unix.go.golden 0000664 0000000 0000000 00000000626 14143223131 0034071 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckUntrappableSignal //go:build android || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
// +build android darwin dragonfly freebsd linux netbsd openbsd solaris
package main
import (
"os"
"os/signal"
"syscall"
)
func fn2() {
c := make(chan os.Signal, 1)
signal.Ignore() // want `cannot be trapped`
signal.Notify(c) // want `cannot be trapped`
signal.Reset() // want `cannot be trapped`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckWaitgroupAdd/ 0000775 0000000 0000000 00000000000 14143223131 0023711 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckWaitgroupAdd/CheckWaitgroupAdd.go 0000664 0000000 0000000 00000000602 14143223131 0027566 0 ustar 00root root 0000000 0000000 package pkg
import (
"sync"
)
func fn() {
wg := sync.WaitGroup{}
wg.Add(1)
go func() {
wg.Done()
}()
go func() {
wg.Add(1) // want `should call wg\.Add\(1\) before starting`
wg.Done()
}()
wg.Add(1)
go func(wg sync.WaitGroup) {
wg.Done()
}(wg)
wg.Add(1)
go func(wg *sync.WaitGroup) {
wg.Done()
}(&wg)
wg.Wait()
}
func fn2(wg sync.WaitGroup) {
wg.Add(1)
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckWithValueKey/ 0000775 0000000 0000000 00000000000 14143223131 0023700 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckWithValueKey/CheckWithValueKey.go 0000664 0000000 0000000 00000001547 14143223131 0027555 0 ustar 00root root 0000000 0000000 package pkg
import "context"
type T string
type T2 struct {
A int
}
type T3 struct {
A []int
}
func fn(arg1 interface{}, arg2 string) {
var ctx context.Context
context.WithValue(ctx, "hi", nil) // want `should not use built-in type string`
context.WithValue(ctx, arg1, nil)
context.WithValue(ctx, arg2, nil) // want `should not use built-in type string`
v1 := interface{}("byte")
context.WithValue(ctx, v1, nil) // want `should not use built-in type string`
var key T
context.WithValue(ctx, key, nil)
v2 := interface{}(key)
context.WithValue(ctx, v2, nil)
context.WithValue(ctx, T(""), nil)
context.WithValue(ctx, string(key), nil) // want `should not use built-in type string`
context.WithValue(ctx, []byte(nil), nil) // want `must be comparable`
context.WithValue(ctx, T2{}, nil)
context.WithValue(ctx, T3{}, nil) // want `must be comparable`
}
go-tools-2021.1.2/staticcheck/testdata/src/CheckWriterBufferModified/ 0000775 0000000 0000000 00000000000 14143223131 0025366 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/CheckWriterBufferModified/CheckWriterBufferModified.go 0000664 0000000 0000000 00000000765 14143223131 0032732 0 ustar 00root root 0000000 0000000 package pkg
type T1 struct{}
type T2 struct{}
type T3 struct{}
type T4 struct{}
func (T1) Write(b []byte) (int, error) {
b = append(b, '\n') // want `io\.Writer\.Write must not modify the provided buffer`
_ = b
return 0, nil
}
func (T2) Write(b []byte) (int, error) {
b[0] = 0 // want `io\.Writer\.Write must not modify the provided buffer`
return 0, nil
}
func (T3) Write(b []byte) string {
b[0] = 0
return ""
}
func (T4) Write(b []byte, r byte) (int, error) {
b[0] = r
return 0, nil
}
go-tools-2021.1.2/staticcheck/testdata/src/_CheckPredeterminedBooleanExprs.go.disabled 0000664 0000000 0000000 00000000554 14143223131 0030670 0 ustar 00root root 0000000 0000000 package pkg
import "math"
func fn1() {
var x int
var y int
println(x == 0) // MATCH /x == 0 is always true for all possible values/
println(x == y) // MATCH /x == y is always true for all possible values/
x = 1
println(x > 0) // MATCH /x > 0 is always true for all possible values/
f := math.NaN()
println(f == f)
}
func fn2(x int) {
println(x == 0)
}
go-tools-2021.1.2/staticcheck/testdata/src/_CheckSliceOutOfBounds.go.disabled 0000664 0000000 0000000 00000001535 14143223131 0026746 0 ustar 00root root 0000000 0000000 package pkg
func fn1() {
var s []int
s[0] = 0 // MATCH /index out of bounds/
}
func fn2() {
s := make([]int, 2)
s[2] = 0 // MATCH /index out of bounds/
}
func fn3() {
var s []int
s[0] = 0 // MATCH /index out of bounds/
s = make([]int, 2)
s[2] = 0 // MATCH /index out of bounds/
}
func fn4() {
s := make([]int, 2)
s = append(s, 1)
s[0] = 0
s[1] = 0
s[2] = 0
s[3] = 0 // MATCH /index out of bounds/
}
func fn5(s []int) {
s[2] = 0
}
func fn6(s []int) {
s = s[:2]
s[2] = 0 // MATCH /index out of bounds/
}
func fn7() {
s := make([]int, 2)
fn(s[2]) // MATCH /index out of bounds/
}
func fn8() {
s := []int{}
s[0] = 1 // MATCH /index out of bounds/
}
func fn9() {
s := []int{}
ptr(&s)
s[0] = 1
}
func fn10() {
var x []byte
for _, y := range x {
println(y)
}
}
func fn(int) {
println() // make it unpure
}
func ptr(*[]int) {}
go-tools-2021.1.2/staticcheck/testdata/src/checkStdlibUsageNilContext/ 0000775 0000000 0000000 00000000000 14143223131 0025575 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/checkStdlibUsageNilContext/checkStdlibUsageNilContext.go 0000664 0000000 0000000 00000000656 14143223131 0033347 0 ustar 00root root 0000000 0000000 package pkg
import "context"
func fn1(ctx context.Context) {}
func fn2(x string, ctx context.Context) {}
func fn4() {}
type T struct{}
func (*T) Foo() {}
func fn3() {
fn1(nil) // want `do not pass a nil Context`
fn1(context.TODO())
fn2("", nil)
fn4()
// don't flag this conversion
_ = (func(context.Context))(nil)
// and don't crash on these
_ = (func())(nil)
(*T).Foo(nil)
}
checkStdlibUsageNilContext.go.golden 0000664 0000000 0000000 00000001654 14143223131 0034536 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/checkStdlibUsageNilContext -- use context.Background --
package pkg
import "context"
func fn1(ctx context.Context) {}
func fn2(x string, ctx context.Context) {}
func fn4() {}
type T struct{}
func (*T) Foo() {}
func fn3() {
fn1(context.Background()) // want `do not pass a nil Context`
fn1(context.TODO())
fn2("", nil)
fn4()
// don't flag this conversion
_ = (func(context.Context))(nil)
// and don't crash on these
_ = (func())(nil)
(*T).Foo(nil)
}
-- use context.TODO --
package pkg
import "context"
func fn1(ctx context.Context) {}
func fn2(x string, ctx context.Context) {}
func fn4() {}
type T struct{}
func (*T) Foo() {}
func fn3() {
fn1(context.TODO()) // want `do not pass a nil Context`
fn1(context.TODO())
fn2("", nil)
fn4()
// don't flag this conversion
_ = (func(context.Context))(nil)
// and don't crash on these
_ = (func())(nil)
(*T).Foo(nil)
}
go-tools-2021.1.2/staticcheck/testdata/src/checkStdlibUsageRegexpFindAll/ 0000775 0000000 0000000 00000000000 14143223131 0026172 5 ustar 00root root 0000000 0000000 checkStdlibUsageRegexpFindAll.go 0000664 0000000 0000000 00000000366 14143223131 0034260 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/checkStdlibUsageRegexpFindAll package pkg
import "regexp"
func fn() {
var r *regexp.Regexp
_ = r.FindAll(nil, 0) //want `calling a FindAll method with n == 0 will return no results`
}
func fn2() {
regexp.MustCompile("foo(").FindAll(nil, 0) // want `calling a FindAll`
}
go-tools-2021.1.2/staticcheck/testdata/src/checkStdlibUsageSeeker/ 0000775 0000000 0000000 00000000000 14143223131 0024724 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/checkStdlibUsageSeeker/checkStdlibUsageSeeker.go 0000664 0000000 0000000 00000000335 14143223131 0031617 0 ustar 00root root 0000000 0000000 package pkg
import "io"
func fn() {
const SeekStart = 0
var s io.Seeker
s.Seek(0, 0)
s.Seek(0, io.SeekStart)
s.Seek(io.SeekStart, 0) // want `the first argument of io\.Seeker is the offset`
s.Seek(SeekStart, 0)
}
go-tools-2021.1.2/staticcheck/testdata/src/checkStdlibUsageSeeker/checkStdlibUsageSeeker.go.golden 0000664 0000000 0000000 00000000335 14143223131 0033066 0 ustar 00root root 0000000 0000000 package pkg
import "io"
func fn() {
const SeekStart = 0
var s io.Seeker
s.Seek(0, 0)
s.Seek(0, io.SeekStart)
s.Seek(0, io.SeekStart) // want `the first argument of io\.Seeker is the offset`
s.Seek(SeekStart, 0)
}
go-tools-2021.1.2/staticcheck/testdata/src/checkStdlibUsageUTF8Cutset/ 0000775 0000000 0000000 00000000000 14143223131 0025424 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/checkStdlibUsageUTF8Cutset/checkStdlibUsageUTF8Cutset.go 0000664 0000000 0000000 00000000362 14143223131 0033017 0 ustar 00root root 0000000 0000000 package pkg
import "strings"
func fn() {
println(strings.Trim("\x80test\xff", "\xff")) // want `is not a valid UTF-8 encoded string`
println(strings.Trim("foo", "bar"))
s := "\xff"
if true {
s = ""
}
println(strings.Trim("", s))
}
go-tools-2021.1.2/staticcheck/testdata/src/github.com/ 0000775 0000000 0000000 00000000000 14143223131 0022420 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/github.com/golang/ 0000775 0000000 0000000 00000000000 14143223131 0023667 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/github.com/golang/protobuf/ 0000775 0000000 0000000 00000000000 14143223131 0025527 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/github.com/golang/protobuf/proto/ 0000775 0000000 0000000 00000000000 14143223131 0026672 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/github.com/golang/protobuf/proto/pkg.go 0000664 0000000 0000000 00000000121 14143223131 0027774 0 ustar 00root root 0000000 0000000 // Package proto exists.
//
// Deprecated: Alas, it is deprecated.
package proto
go-tools-2021.1.2/staticcheck/testdata/src/github.com/jessevdk/ 0000775 0000000 0000000 00000000000 14143223131 0024236 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/github.com/jessevdk/go-flags/ 0000775 0000000 0000000 00000000000 14143223131 0025735 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/staticcheck/testdata/src/github.com/jessevdk/go-flags/pkg.go 0000664 0000000 0000000 00000000014 14143223131 0027040 0 ustar 00root root 0000000 0000000 package pkg
go-tools-2021.1.2/structlayout/ 0000775 0000000 0000000 00000000000 14143223131 0016256 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/structlayout/layout.go 0000664 0000000 0000000 00000001052 14143223131 0020120 0 ustar 00root root 0000000 0000000 package structlayout
import "fmt"
type Field struct {
Name string `json:"name"`
Type string `json:"type"`
Start int64 `json:"start"`
End int64 `json:"end"`
Size int64 `json:"size"`
Align int64 `json:"align"`
IsPadding bool `json:"is_padding"`
}
func (f Field) String() string {
if f.IsPadding {
return fmt.Sprintf("%s: %d-%d (size %d, align %d)",
"padding", f.Start, f.End, f.Size, f.Align)
}
return fmt.Sprintf("%s %s: %d-%d (size %d, align %d)",
f.Name, f.Type, f.Start, f.End, f.Size, f.Align)
}
go-tools-2021.1.2/stylecheck/ 0000775 0000000 0000000 00000000000 14143223131 0015632 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/analysis.go 0000664 0000000 0000000 00000004526 14143223131 0020013 0 ustar 00root root 0000000 0000000 package stylecheck
import (
"honnef.co/go/tools/analysis/facts"
"honnef.co/go/tools/analysis/lint"
"honnef.co/go/tools/config"
"honnef.co/go/tools/internal/passes/buildir"
"honnef.co/go/tools/internal/sharedcheck"
"golang.org/x/tools/go/analysis"
"golang.org/x/tools/go/analysis/passes/inspect"
)
var Analyzers = lint.InitializeAnalyzers(Docs, map[string]*analysis.Analyzer{
"ST1000": {
Run: CheckPackageComment,
},
"ST1001": {
Run: CheckDotImports,
Requires: []*analysis.Analyzer{facts.Generated, config.Analyzer},
},
"ST1003": {
Run: CheckNames,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated, config.Analyzer},
},
"ST1005": {
Run: CheckErrorStrings,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"ST1006": {
Run: CheckReceiverNames,
Requires: []*analysis.Analyzer{buildir.Analyzer, facts.Generated},
},
"ST1008": {
Run: CheckErrorReturn,
Requires: []*analysis.Analyzer{buildir.Analyzer},
},
"ST1011": {
Run: CheckTimeNames,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"ST1012": {
Run: CheckErrorVarNames,
},
"ST1013": {
Run: CheckHTTPStatusCodes,
// TODO(dh): why does this depend on facts.TokenFile?
Requires: []*analysis.Analyzer{facts.Generated, facts.TokenFile, config.Analyzer, inspect.Analyzer},
},
"ST1015": {
Run: CheckDefaultCaseOrder,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated, facts.TokenFile},
},
"ST1016": {
Run: CheckReceiverNamesIdentical,
Requires: []*analysis.Analyzer{buildir.Analyzer, facts.Generated},
},
"ST1017": {
Run: CheckYodaConditions,
Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated, facts.TokenFile},
},
"ST1018": {
Run: CheckInvisibleCharacters,
Requires: []*analysis.Analyzer{inspect.Analyzer},
},
"ST1019": {
Run: CheckDuplicatedImports,
Requires: []*analysis.Analyzer{facts.Generated},
},
"ST1020": {
Run: CheckExportedFunctionDocs,
Requires: []*analysis.Analyzer{facts.Generated, inspect.Analyzer},
},
"ST1021": {
Run: CheckExportedTypeDocs,
Requires: []*analysis.Analyzer{facts.Generated, inspect.Analyzer},
},
"ST1022": {
Run: CheckExportedVarDocs,
Requires: []*analysis.Analyzer{facts.Generated, inspect.Analyzer},
},
"ST1023": sharedcheck.RedundantTypeInDeclarationChecker("should", false),
})
go-tools-2021.1.2/stylecheck/doc.go 0000664 0000000 0000000 00000017744 14143223131 0016743 0 ustar 00root root 0000000 0000000 package stylecheck
import "honnef.co/go/tools/analysis/lint"
var Docs = lint.Markdownify(map[string]*lint.Documentation{
"ST1000": {
Title: `Incorrect or missing package comment`,
Text: `Packages must have a package comment that is formatted according to
the guidelines laid out in
https://github.com/golang/go/wiki/CodeReviewComments#package-comments.`,
Since: "2019.1",
NonDefault: true,
},
"ST1001": {
Title: `Dot imports are discouraged`,
Text: `Dot imports that aren't in external test packages are discouraged.
The \'dot_import_whitelist\' option can be used to whitelist certain
imports.
Quoting Go Code Review Comments:
> The import . form can be useful in tests that, due to circular
> dependencies, cannot be made part of the package being tested:
>
> package foo_test
>
> import (
> "bar/testutil" // also imports "foo"
> . "foo"
> )
>
> In this case, the test file cannot be in package foo because it
> uses bar/testutil, which imports foo. So we use the 'import .'
> form to let the file pretend to be part of package foo even though
> it is not. Except for this one case, do not use import . in your
> programs. It makes the programs much harder to read because it is
> unclear whether a name like Quux is a top-level identifier in the
> current package or in an imported package.`,
Since: "2019.1",
Options: []string{"dot_import_whitelist"},
},
"ST1003": {
Title: `Poorly chosen identifier`,
Text: `Identifiers, such as variable and package names, follow certain rules.
See the following links for details:
- https://golang.org/doc/effective_go.html#package-names
- https://golang.org/doc/effective_go.html#mixed-caps
- https://github.com/golang/go/wiki/CodeReviewComments#initialisms
- https://github.com/golang/go/wiki/CodeReviewComments#variable-names`,
Since: "2019.1",
NonDefault: true,
Options: []string{"initialisms"},
},
"ST1005": {
Title: `Incorrectly formatted error string`,
Text: `Error strings follow a set of guidelines to ensure uniformity and good
composability.
Quoting Go Code Review Comments:
> Error strings should not be capitalized (unless beginning with
> proper nouns or acronyms) or end with punctuation, since they are
> usually printed following other context. That is, use
> fmt.Errorf("something bad") not fmt.Errorf("Something bad"), so
> that log.Printf("Reading %s: %v", filename, err) formats without a
> spurious capital letter mid-message.`,
Since: "2019.1",
},
"ST1006": {
Title: `Poorly chosen receiver name`,
Text: `Quoting Go Code Review Comments:
> The name of a method's receiver should be a reflection of its
> identity; often a one or two letter abbreviation of its type
> suffices (such as "c" or "cl" for "Client"). Don't use generic
> names such as "me", "this" or "self", identifiers typical of
> object-oriented languages that place more emphasis on methods as
> opposed to functions. The name need not be as descriptive as that
> of a method argument, as its role is obvious and serves no
> documentary purpose. It can be very short as it will appear on
> almost every line of every method of the type; familiarity admits
> brevity. Be consistent, too: if you call the receiver "c" in one
> method, don't call it "cl" in another.`,
Since: "2019.1",
},
"ST1008": {
Title: `A function's error value should be its last return value`,
Text: `A function's error value should be its last return value.`,
Since: `2019.1`,
},
"ST1011": {
Title: "Poorly chosen name for variable of type `time.Duration`",
Text: `\'time.Duration\' values represent an amount of time, which is represented
as a count of nanoseconds. An expression like \'5 * time.Microsecond\'
yields the value \'5000\'. It is therefore not appropriate to suffix a
variable of type \'time.Duration\' with any time unit, such as \'Msec or
Milli\'.`,
Since: `2019.1`,
},
"ST1012": {
Title: `Poorly chosen name for error variable`,
Text: `Error variables that are part of an API should be called \'errFoo\' or
\'ErrFoo\'.`,
Since: "2019.1",
},
"ST1013": {
Title: `Should use constants for HTTP error codes, not magic numbers`,
Text: `HTTP has a tremendous number of status codes. While some of those are
well known (200, 400, 404, 500), most of them are not. The \'net/http\'
package provides constants for all status codes that are part of the
various specifications. It is recommended to use these constants
instead of hard-coding magic numbers, to vastly improve the
readability of your code.`,
Since: "2019.1",
Options: []string{"http_status_code_whitelist"},
},
"ST1015": {
Title: `A switch's default case should be the first or last case`,
Since: "2019.1",
},
"ST1016": {
Title: `Use consistent method receiver names`,
Since: "2019.1",
NonDefault: true,
},
"ST1017": {
Title: `Don't use Yoda conditions`,
Text: `Yoda conditions are conditions of the kind \'if 42 == x\', where the
literal is on the left side of the comparison. These are a common
idiom in languages in which assignment is an expression, to avoid bugs
of the kind \'if (x = 42)\'. In Go, which doesn't allow for this kind of
bug, we prefer the more idiomatic \'if x == 42\'.`,
Since: "2019.2",
},
"ST1018": {
Title: `Avoid zero-width and control characters in string literals`,
Since: "2019.2",
},
"ST1019": {
Title: `Importing the same package multiple times`,
Text: `Go allows importing the same package multiple times, as long as
different import aliases are being used. That is, the following
bit of code is valid:
import (
"fmt"
fumpt "fmt"
format "fmt"
_ "fmt"
)
However, this is very rarely done on purpose. Usually, it is a
sign of code that got refactored, accidentally adding duplicate
import statements. It is also a rarely known feature, which may
contribute to confusion.
Do note that sometimes, this feature may be used
intentionally (see for example
https://github.com/golang/go/commit/3409ce39bfd7584523b7a8c150a310cea92d879d)
β if you want to allow this pattern in your code base, you're
advised to disable this check.`,
Since: "2020.1",
},
"ST1020": {
Title: "The documentation of an exported function should start with the function's name",
Text: `Doc comments work best as complete sentences, which
allow a wide variety of automated presentations. The first sentence
should be a one-sentence summary that starts with the name being
declared.
If every doc comment begins with the name of the item it describes,
you can use the doc subcommand of the go tool and run the output
through grep.
See https://golang.org/doc/effective_go.html#commentary for more
information on how to write good documentation.`,
Since: "2020.1",
NonDefault: true,
},
"ST1021": {
Title: "The documentation of an exported type should start with type's name",
Text: `Doc comments work best as complete sentences, which
allow a wide variety of automated presentations. The first sentence
should be a one-sentence summary that starts with the name being
declared.
If every doc comment begins with the name of the item it describes,
you can use the \'doc\' subcommand of the \'go\' tool and run the output
through grep.
See https://golang.org/doc/effective_go.html#commentary for more
information on how to write good documentation.`,
Since: "2020.1",
NonDefault: true,
},
"ST1022": {
Title: "The documentation of an exported variable or constant should start with variable's name",
Text: `Doc comments work best as complete sentences, which
allow a wide variety of automated presentations. The first sentence
should be a one-sentence summary that starts with the name being
declared.
If every doc comment begins with the name of the item it describes,
you can use the doc subcommand of the go tool and run the output
through grep.
See https://golang.org/doc/effective_go.html#commentary for more
information on how to write good documentation.`,
Since: "2020.1",
NonDefault: true,
},
"ST1023": {
Title: "Redundant type in variable declaration",
Since: "2021.1",
NonDefault: true,
},
})
go-tools-2021.1.2/stylecheck/lint.go 0000664 0000000 0000000 00000062653 14143223131 0017143 0 ustar 00root root 0000000 0000000 package stylecheck
import (
"fmt"
"go/ast"
"go/constant"
"go/token"
"go/types"
"sort"
"strconv"
"strings"
"unicode"
"unicode/utf8"
"honnef.co/go/tools/analysis/code"
"honnef.co/go/tools/analysis/edit"
"honnef.co/go/tools/analysis/lint"
"honnef.co/go/tools/analysis/report"
"honnef.co/go/tools/config"
"honnef.co/go/tools/go/ast/astutil"
"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"
"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 docText(doc *ast.CommentGroup) (string, bool) {
if doc == nil {
return "", false
}
// We trim spaces primarily because of /**/ style comments, which often have leading space.
text := strings.TrimSpace(doc.Text())
return text, text != ""
}
func CheckPackageComment(pass *analysis.Pass) (interface{}, error) {
// - At least one file in a non-main package should have a package comment
//
// - The comment should be of the form
// "Package x ...". This has a slight potential for false
// positives, as multiple files can have package comments, in
// which case they get appended. But that doesn't happen a lot in
// the real world.
if pass.Pkg.Name() == "main" {
return nil, nil
}
hasDocs := false
for _, f := range pass.Files {
if code.IsInTest(pass, f) {
continue
}
text, ok := docText(f.Doc)
if ok {
hasDocs = true
prefix := "Package " + f.Name.Name + " "
if !strings.HasPrefix(text, prefix) {
report.Report(pass, f.Doc, fmt.Sprintf(`package comment should be of the form "%s..."`, prefix))
}
}
}
if !hasDocs {
for _, f := range pass.Files {
if code.IsInTest(pass, f) {
continue
}
report.Report(pass, f, "at least one file in a package should have a package comment", report.ShortRange())
}
}
return nil, nil
}
func CheckDotImports(pass *analysis.Pass) (interface{}, error) {
for _, f := range pass.Files {
imports:
for _, imp := range f.Imports {
path := imp.Path.Value
path = path[1 : len(path)-1]
for _, w := range config.For(pass).DotImportWhitelist {
if w == path {
continue imports
}
}
if imp.Name != nil && imp.Name.Name == "." && !code.IsInTest(pass, f) {
report.Report(pass, imp, "should not use dot imports", report.FilterGenerated())
}
}
}
return nil, nil
}
func CheckDuplicatedImports(pass *analysis.Pass) (interface{}, error) {
for _, f := range pass.Files {
// Collect all imports by their import path
imports := make(map[string][]*ast.ImportSpec, len(f.Imports))
for _, imp := range f.Imports {
imports[imp.Path.Value] = append(imports[imp.Path.Value], imp)
}
for path, value := range imports {
if path[1:len(path)-1] == "unsafe" {
// Don't flag unsafe. Cgo generated code imports
// unsafe using the blank identifier, and most
// user-written cgo code also imports unsafe
// explicitly.
continue
}
// If there's more than one import per path, we flag that
if len(value) > 1 {
s := fmt.Sprintf("package %s is being imported more than once", path)
opts := []report.Option{report.FilterGenerated()}
for _, imp := range value[1:] {
opts = append(opts, report.Related(imp, fmt.Sprintf("other import of %s", path)))
}
report.Report(pass, value[0], s, opts...)
}
}
}
return nil, nil
}
func CheckBlankImports(pass *analysis.Pass) (interface{}, error) {
fset := pass.Fset
for _, f := range pass.Files {
if code.IsMainLike(pass) || code.IsInTest(pass, f) {
continue
}
// Collect imports of the form `import _ "foo"`, i.e. with no
// parentheses, as their comment will be associated with the
// (paren-free) GenDecl, not the import spec itself.
//
// We don't directly process the GenDecl so that we can
// correctly handle the following:
//
// import _ "foo"
// import _ "bar"
//
// where only the first import should get flagged.
skip := map[ast.Spec]bool{}
ast.Inspect(f, func(node ast.Node) bool {
switch node := node.(type) {
case *ast.File:
return true
case *ast.GenDecl:
if node.Tok != token.IMPORT {
return false
}
if node.Lparen == token.NoPos && node.Doc != nil {
skip[node.Specs[0]] = true
}
return false
}
return false
})
for i, imp := range f.Imports {
pos := fset.Position(imp.Pos())
if !astutil.IsBlank(imp.Name) {
continue
}
// Only flag the first blank import in a group of imports,
// or don't flag any of them, if the first one is
// commented
if i > 0 {
prev := f.Imports[i-1]
prevPos := fset.Position(prev.Pos())
if pos.Line-1 == prevPos.Line && astutil.IsBlank(prev.Name) {
continue
}
}
if imp.Doc == nil && imp.Comment == nil && !skip[imp] {
report.Report(pass, imp, "a blank import should be only in a main or test package, or have a comment justifying it")
}
}
}
return nil, nil
}
func CheckIncDec(pass *analysis.Pass) (interface{}, error) {
// TODO(dh): this can be noisy for function bodies that look like this:
// x += 3
// ...
// x += 2
// ...
// x += 1
fn := func(node ast.Node) {
assign := node.(*ast.AssignStmt)
if assign.Tok != token.ADD_ASSIGN && assign.Tok != token.SUB_ASSIGN {
return
}
if (len(assign.Lhs) != 1 || len(assign.Rhs) != 1) ||
!astutil.IsIntLiteral(assign.Rhs[0], "1") {
return
}
suffix := ""
switch assign.Tok {
case token.ADD_ASSIGN:
suffix = "++"
case token.SUB_ASSIGN:
suffix = "--"
}
report.Report(pass, assign, fmt.Sprintf("should replace %s with %s%s", report.Render(pass, assign), report.Render(pass, assign.Lhs[0]), suffix))
}
code.Preorder(pass, fn, (*ast.AssignStmt)(nil))
return nil, nil
}
func CheckErrorReturn(pass *analysis.Pass) (interface{}, error) {
fnLoop:
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
sig := fn.Type().(*types.Signature)
rets := sig.Results()
if rets == nil || rets.Len() < 2 {
continue
}
if rets.At(rets.Len()-1).Type() == types.Universe.Lookup("error").Type() {
// Last return type is error. If the function also returns
// errors in other positions, that's fine.
continue
}
for i := rets.Len() - 2; i >= 0; i-- {
if rets.At(i).Type() == types.Universe.Lookup("error").Type() {
report.Report(pass, rets.At(i), "error should be returned as the last argument", report.ShortRange())
continue fnLoop
}
}
}
return nil, nil
}
// CheckUnexportedReturn checks that exported functions on exported
// types do not return unexported types.
func CheckUnexportedReturn(pass *analysis.Pass) (interface{}, error) {
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
if fn.Synthetic != 0 || fn.Parent() != nil {
continue
}
if !ast.IsExported(fn.Name()) || code.IsMain(pass) || code.IsInTest(pass, fn) {
continue
}
sig := fn.Type().(*types.Signature)
if sig.Recv() != nil && !ast.IsExported(typeutil.Dereference(sig.Recv().Type()).(*types.Named).Obj().Name()) {
continue
}
res := sig.Results()
for i := 0; i < res.Len(); i++ {
if named, ok := typeutil.DereferenceR(res.At(i).Type()).(*types.Named); ok &&
!ast.IsExported(named.Obj().Name()) &&
named != types.Universe.Lookup("error").Type() {
report.Report(pass, fn, "should not return unexported type")
}
}
}
return nil, nil
}
func CheckReceiverNames(pass *analysis.Pass) (interface{}, error) {
irpkg := pass.ResultOf[buildir.Analyzer].(*buildir.IR).Pkg
for _, m := range irpkg.Members {
if T, ok := m.Object().(*types.TypeName); ok && !T.IsAlias() {
ms := typeutil.IntuitiveMethodSet(T.Type(), nil)
for _, sel := range ms {
fn := sel.Obj().(*types.Func)
recv := fn.Type().(*types.Signature).Recv()
if typeutil.Dereference(recv.Type()) != T.Type() {
// skip embedded methods
continue
}
if recv.Name() == "self" || recv.Name() == "this" {
report.Report(pass, recv, `receiver name should be a reflection of its identity; don't use generic names such as "this" or "self"`, report.FilterGenerated())
}
if recv.Name() == "_" {
report.Report(pass, recv, "receiver name should not be an underscore, omit the name if it is unused", report.FilterGenerated())
}
}
}
}
return nil, nil
}
func CheckReceiverNamesIdentical(pass *analysis.Pass) (interface{}, error) {
irpkg := pass.ResultOf[buildir.Analyzer].(*buildir.IR).Pkg
for _, m := range irpkg.Members {
names := map[string]int{}
var firstFn *types.Func
if T, ok := m.Object().(*types.TypeName); ok && !T.IsAlias() {
ms := typeutil.IntuitiveMethodSet(T.Type(), nil)
for _, sel := range ms {
fn := sel.Obj().(*types.Func)
recv := fn.Type().(*types.Signature).Recv()
if code.IsGenerated(pass, recv.Pos()) {
// Don't concern ourselves with methods in generated code
continue
}
if typeutil.Dereference(recv.Type()) != T.Type() {
// skip embedded methods
continue
}
if firstFn == nil {
firstFn = fn
}
if recv.Name() != "" && recv.Name() != "_" {
names[recv.Name()]++
}
}
}
if len(names) > 1 {
var seen []string
for name, count := range names {
seen = append(seen, fmt.Sprintf("%dx %q", count, name))
}
sort.Strings(seen)
report.Report(pass, firstFn, fmt.Sprintf("methods on the same type should have the same receiver name (seen %s)", strings.Join(seen, ", ")))
}
}
return nil, nil
}
func CheckContextFirstArg(pass *analysis.Pass) (interface{}, error) {
// TODO(dh): this check doesn't apply to test helpers. Example from the stdlib:
// func helperCommandContext(t *testing.T, ctx context.Context, s ...string) (cmd *exec.Cmd) {
fnLoop:
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
if fn.Synthetic != 0 || fn.Parent() != nil {
continue
}
params := fn.Signature.Params()
if params.Len() < 2 {
continue
}
if types.TypeString(params.At(0).Type(), nil) == "context.Context" {
continue
}
for i := 1; i < params.Len(); i++ {
param := params.At(i)
if types.TypeString(param.Type(), nil) == "context.Context" {
report.Report(pass, param, "context.Context should be the first argument of a function", report.ShortRange())
continue fnLoop
}
}
}
return nil, nil
}
func CheckErrorStrings(pass *analysis.Pass) (interface{}, error) {
objNames := map[*ir.Package]map[string]bool{}
irpkg := pass.ResultOf[buildir.Analyzer].(*buildir.IR).Pkg
objNames[irpkg] = map[string]bool{}
for _, m := range irpkg.Members {
if typ, ok := m.(*ir.Type); ok {
objNames[irpkg][typ.Name()] = true
}
}
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
objNames[fn.Package()][fn.Name()] = true
}
for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
if code.IsInTest(pass, fn) {
// We don't care about malformed error messages in tests;
// they're usually for direct human consumption, not part
// of an API
continue
}
for _, block := range fn.Blocks {
instrLoop:
for _, ins := range block.Instrs {
call, ok := ins.(*ir.Call)
if !ok {
continue
}
if !irutil.IsCallToAny(call.Common(), "errors.New", "fmt.Errorf") {
continue
}
k, ok := call.Common().Args[0].(*ir.Const)
if !ok {
continue
}
s := constant.StringVal(k.Value)
if len(s) == 0 {
continue
}
switch s[len(s)-1] {
case '.', ':', '!', '\n':
report.Report(pass, call, "error strings should not end with punctuation or a newline")
}
idx := strings.IndexByte(s, ' ')
if idx == -1 {
// single word error message, probably not a real
// error but something used in tests or during
// debugging
continue
}
word := s[:idx]
first, n := utf8.DecodeRuneInString(word)
if !unicode.IsUpper(first) {
continue
}
for _, c := range word[n:] {
if unicode.IsUpper(c) {
// Word is probably an initialism or
// multi-word function name
continue instrLoop
}
}
if strings.ContainsRune(word, '(') {
// Might be a function call
continue instrLoop
}
word = strings.TrimRightFunc(word, func(r rune) bool { return unicode.IsPunct(r) })
if objNames[fn.Package()][word] {
// Word is probably the name of a function or type in this package
continue
}
// First word in error starts with a capital
// letter, and the word doesn't contain any other
// capitals, making it unlikely to be an
// initialism or multi-word function name.
//
// It could still be a proper noun, though.
report.Report(pass, call, "error strings should not be capitalized")
}
}
}
return nil, nil
}
func CheckTimeNames(pass *analysis.Pass) (interface{}, error) {
suffixes := []string{
"Sec", "Secs", "Seconds",
"Msec", "Msecs",
"Milli", "Millis", "Milliseconds",
"Usec", "Usecs", "Microseconds",
"MS", "Ms",
}
fn := func(names []*ast.Ident) {
for _, name := range names {
if _, ok := pass.TypesInfo.Defs[name]; !ok {
continue
}
T := pass.TypesInfo.TypeOf(name)
if !typeutil.IsType(T, "time.Duration") && !typeutil.IsType(T, "*time.Duration") {
continue
}
for _, suffix := range suffixes {
if strings.HasSuffix(name.Name, suffix) {
report.Report(pass, name, fmt.Sprintf("var %s is of type %v; don't use unit-specific suffix %q", name.Name, T, suffix))
break
}
}
}
}
fn2 := func(node ast.Node) {
switch node := node.(type) {
case *ast.ValueSpec:
fn(node.Names)
case *ast.FieldList:
for _, field := range node.List {
fn(field.Names)
}
case *ast.AssignStmt:
if node.Tok != token.DEFINE {
break
}
var names []*ast.Ident
for _, lhs := range node.Lhs {
if lhs, ok := lhs.(*ast.Ident); ok {
names = append(names, lhs)
}
}
fn(names)
}
}
code.Preorder(pass, fn2, (*ast.ValueSpec)(nil), (*ast.FieldList)(nil), (*ast.AssignStmt)(nil))
return nil, nil
}
func CheckErrorVarNames(pass *analysis.Pass) (interface{}, error) {
for _, f := range pass.Files {
for _, decl := range f.Decls {
gen, ok := decl.(*ast.GenDecl)
if !ok || gen.Tok != token.VAR {
continue
}
for _, spec := range gen.Specs {
spec := spec.(*ast.ValueSpec)
if len(spec.Names) != len(spec.Values) {
continue
}
for i, name := range spec.Names {
val := spec.Values[i]
if !code.IsCallToAny(pass, val, "errors.New", "fmt.Errorf") {
continue
}
if pass.Pkg.Path() == "net/http" && strings.HasPrefix(name.Name, "http2err") {
// special case for internal variable names of
// bundled HTTP 2 code in net/http
continue
}
prefix := "err"
if name.IsExported() {
prefix = "Err"
}
if !strings.HasPrefix(name.Name, prefix) {
report.Report(pass, name, fmt.Sprintf("error var %s should have name of the form %sFoo", name.Name, prefix))
}
}
}
}
}
return nil, nil
}
var httpStatusCodes = map[int]string{
100: "StatusContinue",
101: "StatusSwitchingProtocols",
102: "StatusProcessing",
200: "StatusOK",
201: "StatusCreated",
202: "StatusAccepted",
203: "StatusNonAuthoritativeInfo",
204: "StatusNoContent",
205: "StatusResetContent",
206: "StatusPartialContent",
207: "StatusMultiStatus",
208: "StatusAlreadyReported",
226: "StatusIMUsed",
300: "StatusMultipleChoices",
301: "StatusMovedPermanently",
302: "StatusFound",
303: "StatusSeeOther",
304: "StatusNotModified",
305: "StatusUseProxy",
307: "StatusTemporaryRedirect",
308: "StatusPermanentRedirect",
400: "StatusBadRequest",
401: "StatusUnauthorized",
402: "StatusPaymentRequired",
403: "StatusForbidden",
404: "StatusNotFound",
405: "StatusMethodNotAllowed",
406: "StatusNotAcceptable",
407: "StatusProxyAuthRequired",
408: "StatusRequestTimeout",
409: "StatusConflict",
410: "StatusGone",
411: "StatusLengthRequired",
412: "StatusPreconditionFailed",
413: "StatusRequestEntityTooLarge",
414: "StatusRequestURITooLong",
415: "StatusUnsupportedMediaType",
416: "StatusRequestedRangeNotSatisfiable",
417: "StatusExpectationFailed",
418: "StatusTeapot",
422: "StatusUnprocessableEntity",
423: "StatusLocked",
424: "StatusFailedDependency",
426: "StatusUpgradeRequired",
428: "StatusPreconditionRequired",
429: "StatusTooManyRequests",
431: "StatusRequestHeaderFieldsTooLarge",
451: "StatusUnavailableForLegalReasons",
500: "StatusInternalServerError",
501: "StatusNotImplemented",
502: "StatusBadGateway",
503: "StatusServiceUnavailable",
504: "StatusGatewayTimeout",
505: "StatusHTTPVersionNotSupported",
506: "StatusVariantAlsoNegotiates",
507: "StatusInsufficientStorage",
508: "StatusLoopDetected",
510: "StatusNotExtended",
511: "StatusNetworkAuthenticationRequired",
}
func CheckHTTPStatusCodes(pass *analysis.Pass) (interface{}, error) {
whitelist := map[string]bool{}
for _, code := range config.For(pass).HTTPStatusCodeWhitelist {
whitelist[code] = true
}
fn := func(node ast.Node) {
call := node.(*ast.CallExpr)
var arg int
switch code.CallName(pass, call) {
case "net/http.Error":
arg = 2
case "net/http.Redirect":
arg = 3
case "net/http.StatusText":
arg = 0
case "net/http.RedirectHandler":
arg = 1
default:
return
}
if arg >= len(call.Args) {
return
}
lit, ok := call.Args[arg].(*ast.BasicLit)
if !ok {
return
}
if whitelist[lit.Value] {
return
}
n, err := strconv.Atoi(lit.Value)
if err != nil {
return
}
s, ok := httpStatusCodes[n]
if !ok {
return
}
report.Report(pass, lit, fmt.Sprintf("should use constant http.%s instead of numeric literal %d", s, n),
report.FilterGenerated(),
report.Fixes(edit.Fix(fmt.Sprintf("use http.%s instead of %d", s, n), edit.ReplaceWithString(pass.Fset, lit, "http."+s))))
}
code.Preorder(pass, fn, (*ast.CallExpr)(nil))
return nil, nil
}
func CheckDefaultCaseOrder(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
stmt := node.(*ast.SwitchStmt)
list := stmt.Body.List
for i, c := range list {
if c.(*ast.CaseClause).List == nil && i != 0 && i != len(list)-1 {
report.Report(pass, c, "default case should be first or last in switch statement", report.FilterGenerated())
break
}
}
}
code.Preorder(pass, fn, (*ast.SwitchStmt)(nil))
return nil, nil
}
var (
checkYodaConditionsQ = pattern.MustParse(`(BinaryExpr left@(BasicLit _ _) tok@(Or "==" "!=") right@(Not (BasicLit _ _)))`)
checkYodaConditionsR = pattern.MustParse(`(BinaryExpr right tok left)`)
)
func CheckYodaConditions(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
if _, edits, ok := code.MatchAndEdit(pass, checkYodaConditionsQ, checkYodaConditionsR, node); ok {
report.Report(pass, node, "don't use Yoda conditions",
report.FilterGenerated(),
report.Fixes(edit.Fix("un-Yoda-fy", edits...)))
}
}
code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
return nil, nil
}
func CheckInvisibleCharacters(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
lit := node.(*ast.BasicLit)
if lit.Kind != token.STRING {
return
}
type invalid struct {
r rune
off int
}
var invalids []invalid
hasFormat := false
hasControl := false
for off, r := range lit.Value {
if unicode.Is(unicode.Cf, r) {
invalids = append(invalids, invalid{r, off})
hasFormat = true
} else if unicode.Is(unicode.Cc, r) && r != '\n' && r != '\t' && r != '\r' {
invalids = append(invalids, invalid{r, off})
hasControl = true
}
}
switch len(invalids) {
case 0:
return
case 1:
var kind string
if hasFormat {
kind = "format"
} else if hasControl {
kind = "control"
} else {
panic("unreachable")
}
r := invalids[0]
msg := fmt.Sprintf("string literal contains the Unicode %s character %U, consider using the %q escape sequence instead", kind, r.r, r.r)
replacement := strconv.QuoteRune(r.r)
replacement = replacement[1 : len(replacement)-1]
edit := analysis.SuggestedFix{
Message: fmt.Sprintf("replace %s character %U with %q", kind, r.r, r.r),
TextEdits: []analysis.TextEdit{{
Pos: lit.Pos() + token.Pos(r.off),
End: lit.Pos() + token.Pos(r.off) + token.Pos(utf8.RuneLen(r.r)),
NewText: []byte(replacement),
}},
}
delete := analysis.SuggestedFix{
Message: fmt.Sprintf("delete %s character %U", kind, r),
TextEdits: []analysis.TextEdit{{
Pos: lit.Pos() + token.Pos(r.off),
End: lit.Pos() + token.Pos(r.off) + token.Pos(utf8.RuneLen(r.r)),
}},
}
report.Report(pass, lit, msg, report.Fixes(edit, delete))
default:
var kind string
if hasFormat && hasControl {
kind = "format and control"
} else if hasFormat {
kind = "format"
} else if hasControl {
kind = "control"
} else {
panic("unreachable")
}
msg := fmt.Sprintf("string literal contains Unicode %s characters, consider using escape sequences instead", kind)
var edits []analysis.TextEdit
var deletions []analysis.TextEdit
for _, r := range invalids {
replacement := strconv.QuoteRune(r.r)
replacement = replacement[1 : len(replacement)-1]
edits = append(edits, analysis.TextEdit{
Pos: lit.Pos() + token.Pos(r.off),
End: lit.Pos() + token.Pos(r.off) + token.Pos(utf8.RuneLen(r.r)),
NewText: []byte(replacement),
})
deletions = append(deletions, analysis.TextEdit{
Pos: lit.Pos() + token.Pos(r.off),
End: lit.Pos() + token.Pos(r.off) + token.Pos(utf8.RuneLen(r.r)),
})
}
edit := analysis.SuggestedFix{
Message: fmt.Sprintf("replace all %s characters with escape sequences", kind),
TextEdits: edits,
}
delete := analysis.SuggestedFix{
Message: fmt.Sprintf("delete all %s characters", kind),
TextEdits: deletions,
}
report.Report(pass, lit, msg, report.Fixes(edit, delete))
}
}
code.Preorder(pass, fn, (*ast.BasicLit)(nil))
return nil, nil
}
func CheckExportedFunctionDocs(pass *analysis.Pass) (interface{}, error) {
fn := func(node ast.Node) {
if code.IsInTest(pass, node) {
return
}
decl := node.(*ast.FuncDecl)
text, ok := docText(decl.Doc)
if !ok {
return
}
if !ast.IsExported(decl.Name.Name) {
return
}
kind := "function"
if decl.Recv != nil {
kind = "method"
switch T := decl.Recv.List[0].Type.(type) {
case *ast.StarExpr:
if !ast.IsExported(T.X.(*ast.Ident).Name) {
return
}
case *ast.Ident:
if !ast.IsExported(T.Name) {
return
}
default:
lint.ExhaustiveTypeSwitch(T)
}
}
prefix := decl.Name.Name + " "
if !strings.HasPrefix(text, prefix) {
report.Report(pass, decl.Doc, fmt.Sprintf(`comment on exported %s %s should be of the form "%s..."`, kind, decl.Name.Name, prefix), report.FilterGenerated())
}
}
code.Preorder(pass, fn, (*ast.FuncDecl)(nil))
return nil, nil
}
func CheckExportedTypeDocs(pass *analysis.Pass) (interface{}, error) {
var genDecl *ast.GenDecl
fn := func(node ast.Node, push bool) bool {
if !push {
genDecl = nil
return false
}
if code.IsInTest(pass, node) {
return false
}
switch node := node.(type) {
case *ast.GenDecl:
if node.Tok == token.IMPORT {
return false
}
genDecl = node
return true
case *ast.TypeSpec:
if !ast.IsExported(node.Name.Name) {
return false
}
doc := node.Doc
text, ok := docText(doc)
if !ok {
if len(genDecl.Specs) != 1 {
// more than one spec in the GenDecl, don't validate the
// docstring
return false
}
if genDecl.Lparen.IsValid() {
// 'type ( T )' is weird, don't guess the user's intention
return false
}
doc = genDecl.Doc
text, ok = docText(doc)
if !ok {
return false
}
}
s := text
articles := [...]string{"A", "An", "The"}
for _, a := range articles {
if strings.HasPrefix(s, a+" ") {
s = s[len(a)+1:]
break
}
}
if !strings.HasPrefix(s, node.Name.Name+" ") {
report.Report(pass, doc, fmt.Sprintf(`comment on exported type %s should be of the form "%s ..." (with optional leading article)`, node.Name.Name, node.Name.Name), report.FilterGenerated())
}
return false
case *ast.FuncLit, *ast.FuncDecl:
return false
default:
lint.ExhaustiveTypeSwitch(node)
return false
}
}
pass.ResultOf[inspect.Analyzer].(*inspector.Inspector).Nodes([]ast.Node{(*ast.GenDecl)(nil), (*ast.TypeSpec)(nil), (*ast.FuncLit)(nil), (*ast.FuncDecl)(nil)}, fn)
return nil, nil
}
func CheckExportedVarDocs(pass *analysis.Pass) (interface{}, error) {
var genDecl *ast.GenDecl
fn := func(node ast.Node, push bool) bool {
if !push {
genDecl = nil
return false
}
if code.IsInTest(pass, node) {
return false
}
switch node := node.(type) {
case *ast.GenDecl:
if node.Tok == token.IMPORT {
return false
}
genDecl = node
return true
case *ast.ValueSpec:
if genDecl.Lparen.IsValid() || len(node.Names) > 1 {
// Don't try to guess the user's intention
return false
}
name := node.Names[0].Name
if !ast.IsExported(name) {
return false
}
text, ok := docText(genDecl.Doc)
if !ok {
return false
}
prefix := name + " "
if !strings.HasPrefix(text, prefix) {
kind := "var"
if genDecl.Tok == token.CONST {
kind = "const"
}
report.Report(pass, genDecl.Doc, fmt.Sprintf(`comment on exported %s %s should be of the form "%s..."`, kind, name, prefix), report.FilterGenerated())
}
return false
case *ast.FuncLit, *ast.FuncDecl:
return false
default:
lint.ExhaustiveTypeSwitch(node)
return false
}
}
pass.ResultOf[inspect.Analyzer].(*inspector.Inspector).Nodes([]ast.Node{(*ast.GenDecl)(nil), (*ast.ValueSpec)(nil), (*ast.FuncLit)(nil), (*ast.FuncDecl)(nil)}, fn)
return nil, nil
}
go-tools-2021.1.2/stylecheck/lint_test.go 0000664 0000000 0000000 00000002170 14143223131 0020166 0 ustar 00root root 0000000 0000000 package stylecheck
import (
"testing"
"honnef.co/go/tools/lint/testutil"
)
func TestAll(t *testing.T) {
checks := map[string][]testutil.Test{
"ST1000": {{Dir: "CheckPackageComment-1"}, {Dir: "CheckPackageComment-2"}, {Dir: "CheckPackageComment-3"}},
"ST1001": {{Dir: "CheckDotImports"}},
"ST1003": {{Dir: "CheckNames"}, {Dir: "CheckNames_generated"}},
"ST1005": {{Dir: "CheckErrorStrings"}},
"ST1006": {{Dir: "CheckReceiverNames"}},
"ST1008": {{Dir: "CheckErrorReturn"}},
"ST1011": {{Dir: "CheckTimeNames"}},
"ST1012": {{Dir: "CheckErrorVarNames"}},
"ST1013": {{Dir: "CheckHTTPStatusCodes"}},
"ST1015": {{Dir: "CheckDefaultCaseOrder"}},
"ST1016": {{Dir: "CheckReceiverNamesIdentical"}},
"ST1017": {{Dir: "CheckYodaConditions"}},
"ST1018": {{Dir: "CheckInvisibleCharacters"}},
"ST1019": {{Dir: "CheckDuplicatedImports"}},
"ST1020": {{Dir: "CheckExportedFunctionDocs"}},
"ST1021": {{Dir: "CheckExportedTypeDocs"}},
"ST1022": {{Dir: "CheckExportedVarDocs"}},
"ST1023": {{Dir: "CheckRedundantTypeInDeclaration"}, {Dir: "CheckRedundantTypeInDeclaration_syscall"}},
}
testutil.Run(t, Analyzers, checks)
}
go-tools-2021.1.2/stylecheck/names.go 0000664 0000000 0000000 00000017372 14143223131 0017276 0 ustar 00root root 0000000 0000000 // Copyright (c) 2013 The Go Authors. All rights reserved.
// Copyright (c) 2018 Dominik Honnef. All rights reserved.
package stylecheck
import (
"fmt"
"go/ast"
"go/token"
"strings"
"unicode"
"honnef.co/go/tools/analysis/code"
"honnef.co/go/tools/analysis/report"
"honnef.co/go/tools/config"
"golang.org/x/tools/go/analysis"
)
// knownNameExceptions is a set of names that are known to be exempt from naming checks.
// This is usually because they are constrained by having to match names in the
// standard library.
var knownNameExceptions = map[string]bool{
"LastInsertId": true, // must match database/sql
"kWh": true,
}
func CheckNames(pass *analysis.Pass) (interface{}, error) {
// A large part of this function is copied from
// github.com/golang/lint, Copyright (c) 2013 The Go Authors,
// licensed under the BSD 3-clause license.
allCaps := func(s string) bool {
hasUppercaseLetters := false
for _, r := range s {
if !hasUppercaseLetters && r >= 'A' && r <= 'Z' {
hasUppercaseLetters = true
}
if !((r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '_') {
return false
}
}
return hasUppercaseLetters
}
check := func(id *ast.Ident, thing string, initialisms map[string]bool) {
if id.Name == "_" {
return
}
if knownNameExceptions[id.Name] {
return
}
// Handle two common styles from other languages that don't belong in Go.
if len(id.Name) >= 5 && allCaps(id.Name) && strings.Contains(id.Name, "_") {
report.Report(pass, id, "should not use ALL_CAPS in Go names; use CamelCase instead", report.FilterGenerated())
return
}
should := lintName(id.Name, initialisms)
if id.Name == should {
return
}
if len(id.Name) > 2 && strings.Contains(id.Name[1:len(id.Name)-1], "_") {
report.Report(pass, id, fmt.Sprintf("should not use underscores in Go names; %s %s should be %s", thing, id.Name, should), report.FilterGenerated())
return
}
report.Report(pass, id, fmt.Sprintf("%s %s should be %s", thing, id.Name, should), report.FilterGenerated())
}
checkList := func(fl *ast.FieldList, thing string, initialisms map[string]bool) {
if fl == nil {
return
}
for _, f := range fl.List {
for _, id := range f.Names {
check(id, thing, initialisms)
}
}
}
il := config.For(pass).Initialisms
initialisms := make(map[string]bool, len(il))
for _, word := range il {
initialisms[word] = true
}
for _, f := range pass.Files {
// Package names need slightly different handling than other names.
if !strings.HasSuffix(f.Name.Name, "_test") && strings.Contains(f.Name.Name, "_") {
report.Report(pass, f, "should not use underscores in package names", report.FilterGenerated())
}
if strings.IndexFunc(f.Name.Name, unicode.IsUpper) != -1 {
report.Report(pass, f, fmt.Sprintf("should not use MixedCaps in package name; %s should be %s", f.Name.Name, strings.ToLower(f.Name.Name)), report.FilterGenerated())
}
}
fn := func(node ast.Node) {
switch v := node.(type) {
case *ast.AssignStmt:
if v.Tok != token.DEFINE {
return
}
for _, exp := range v.Lhs {
if id, ok := exp.(*ast.Ident); ok {
check(id, "var", initialisms)
}
}
case *ast.FuncDecl:
// Functions with no body are defined elsewhere (in
// assembly, or via go:linkname). These are likely to
// be something very low level (such as the runtime),
// where our rules don't apply.
if v.Body == nil {
return
}
if code.IsInTest(pass, v) && (strings.HasPrefix(v.Name.Name, "Example") || strings.HasPrefix(v.Name.Name, "Test") || strings.HasPrefix(v.Name.Name, "Benchmark")) {
return
}
thing := "func"
if v.Recv != nil {
thing = "method"
}
if !isTechnicallyExported(v) {
check(v.Name, thing, initialisms)
}
checkList(v.Type.Params, thing+" parameter", initialisms)
checkList(v.Type.Results, thing+" result", initialisms)
case *ast.GenDecl:
if v.Tok == token.IMPORT {
return
}
var thing string
switch v.Tok {
case token.CONST:
thing = "const"
case token.TYPE:
thing = "type"
case token.VAR:
thing = "var"
}
for _, spec := range v.Specs {
switch s := spec.(type) {
case *ast.TypeSpec:
check(s.Name, thing, initialisms)
case *ast.ValueSpec:
for _, id := range s.Names {
check(id, thing, initialisms)
}
}
}
case *ast.InterfaceType:
// Do not check interface method names.
// They are often constrained by the method names of concrete types.
for _, x := range v.Methods.List {
ft, ok := x.Type.(*ast.FuncType)
if !ok { // might be an embedded interface name
continue
}
checkList(ft.Params, "interface method parameter", initialisms)
checkList(ft.Results, "interface method result", initialisms)
}
case *ast.RangeStmt:
if v.Tok == token.ASSIGN {
return
}
if id, ok := v.Key.(*ast.Ident); ok {
check(id, "range var", initialisms)
}
if id, ok := v.Value.(*ast.Ident); ok {
check(id, "range var", initialisms)
}
case *ast.StructType:
for _, f := range v.Fields.List {
for _, id := range f.Names {
check(id, "struct field", initialisms)
}
}
}
}
needle := []ast.Node{
(*ast.AssignStmt)(nil),
(*ast.FuncDecl)(nil),
(*ast.GenDecl)(nil),
(*ast.InterfaceType)(nil),
(*ast.RangeStmt)(nil),
(*ast.StructType)(nil),
}
code.Preorder(pass, fn, needle...)
return nil, nil
}
// lintName returns a different name if it should be different.
func lintName(name string, initialisms map[string]bool) (should string) {
// A large part of this function is copied from
// github.com/golang/lint, Copyright (c) 2013 The Go Authors,
// licensed under the BSD 3-clause license.
// Fast path for simple cases: "_" and all lowercase.
if name == "_" {
return name
}
if strings.IndexFunc(name, func(r rune) bool { return !unicode.IsLower(r) }) == -1 {
return name
}
// Split camelCase at any lower->upper transition, and split on underscores.
// Check each word for common initialisms.
runes := []rune(name)
w, i := 0, 0 // index of start of word, scan
for i+1 <= len(runes) {
eow := false // whether we hit the end of a word
if i+1 == len(runes) {
eow = true
} else if runes[i+1] == '_' && i+1 != len(runes)-1 {
// underscore; shift the remainder forward over any run of underscores
eow = true
n := 1
for i+n+1 < len(runes) && runes[i+n+1] == '_' {
n++
}
// Leave at most one underscore if the underscore is between two digits
if i+n+1 < len(runes) && unicode.IsDigit(runes[i]) && unicode.IsDigit(runes[i+n+1]) {
n--
}
copy(runes[i+1:], runes[i+n+1:])
runes = runes[:len(runes)-n]
} else if unicode.IsLower(runes[i]) && !unicode.IsLower(runes[i+1]) {
// lower->non-lower
eow = true
}
i++
if !eow {
continue
}
// [w,i) is a word.
word := string(runes[w:i])
if u := strings.ToUpper(word); initialisms[u] {
// Keep consistent case, which is lowercase only at the start.
if w == 0 && unicode.IsLower(runes[w]) {
u = strings.ToLower(u)
}
// All the common initialisms are ASCII,
// so we can replace the bytes exactly.
// TODO(dh): this won't be true once we allow custom initialisms
copy(runes[w:], []rune(u))
} else if w > 0 && strings.ToLower(word) == word {
// already all lowercase, and not the first word, so uppercase the first character.
runes[w] = unicode.ToUpper(runes[w])
}
w = i
}
return string(runes)
}
func isTechnicallyExported(f *ast.FuncDecl) bool {
if f.Recv != nil || f.Doc == nil {
return false
}
const export = "//export "
const linkname = "//go:linkname "
for _, c := range f.Doc.List {
if strings.HasPrefix(c.Text, export) && len(c.Text) == len(export)+len(f.Name.Name) && c.Text[len(export):] == f.Name.Name {
return true
}
if strings.HasPrefix(c.Text, linkname) {
return true
}
}
return false
}
go-tools-2021.1.2/stylecheck/testdata/ 0000775 0000000 0000000 00000000000 14143223131 0017443 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/ 0000775 0000000 0000000 00000000000 14143223131 0020232 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckBlankImports_main/ 0000775 0000000 0000000 00000000000 14143223131 0024601 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckBlankImports_main/CheckBlankImports-1.go 0000664 0000000 0000000 00000000060 14143223131 0030625 0 ustar 00root root 0000000 0000000 // Package pkg ...
package main
import _ "fmt"
go-tools-2021.1.2/stylecheck/testdata/src/CheckContextFirstArg.disabled/ 0000775 0000000 0000000 00000000000 14143223131 0026024 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckContextFirstArg.disabled/CheckContextFirstArg.go 0000664 0000000 0000000 00000000711 14143223131 0032376 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
import "context"
type T int
func fn1(int) {}
func fn2(context.Context, int) {}
func fn3(context.Context, int, context.Context) {}
func fn4(int, context.Context) {} // want `context\.Context should be the first argument of a function`
func (T) FN(int, context.Context) {} // want `context\.Context should be the first argument of a function`
go-tools-2021.1.2/stylecheck/testdata/src/CheckDefaultCaseOrder/ 0000775 0000000 0000000 00000000000 14143223131 0024344 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckDefaultCaseOrder/CheckDefaultCaseOrder.go 0000664 0000000 0000000 00000000524 14143223131 0031006 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
func fn(x int) {
switch x {
}
switch x {
case 1:
}
switch x {
case 1:
case 2:
case 3:
}
switch x {
default:
}
switch x {
default:
case 1:
}
switch x {
case 1:
default:
}
switch x {
case 1:
default: // want `default case should be first or last in switch statement`
case 2:
}
}
go-tools-2021.1.2/stylecheck/testdata/src/CheckDotImports/ 0000775 0000000 0000000 00000000000 14143223131 0023274 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckDotImports/CheckDotImports.go 0000664 0000000 0000000 00000000145 14143223131 0026665 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
import . "fmt" // want `should not use dot imports`
var _ = Println
go-tools-2021.1.2/stylecheck/testdata/src/CheckDotImports/CheckDotImports_test.go 0000664 0000000 0000000 00000000055 14143223131 0027724 0 ustar 00root root 0000000 0000000 package pkg
import . "fmt"
var _ = Println
go-tools-2021.1.2/stylecheck/testdata/src/CheckDuplicatedImports/ 0000775 0000000 0000000 00000000000 14143223131 0024624 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckDuplicatedImports/CheckDuplicatedImports.go 0000664 0000000 0000000 00000000560 14143223131 0031546 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
import (
"fmt" // want `package "fmt" is being imported more than once`
fmt1 "fmt"
fmt2 "fmt"
fine "net/http"
"os" // want `package "os" is being imported more than once`
os1 "os"
"C"
_ "unsafe"
)
var _ = fmt.Println
var _ = fmt1.Println
var _ = fmt2.Println
var _ = fine.ListenAndServe
var _ = os.Getenv
var _ = os1.Getenv
go-tools-2021.1.2/stylecheck/testdata/src/CheckErrorReturn/ 0000775 0000000 0000000 00000000000 14143223131 0023461 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckErrorReturn/CheckErrorReturn.go 0000664 0000000 0000000 00000000770 14143223131 0027243 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
func fn1() (error, int) { return nil, 0 } // want `error should be returned as the last argument`
func fn2() (a, b error, c int) { return nil, nil, 0 } // want `error should be returned as the last argument`
func fn3() (a int, b, c error) { return 0, nil, nil }
func fn4() (error, error) { return nil, nil }
func fn5() int { return 0 }
func fn6() (int, error) { return 0, nil }
func fn7() (error, int, error) { return nil, 0, nil }
go-tools-2021.1.2/stylecheck/testdata/src/CheckErrorStrings/ 0000775 0000000 0000000 00000000000 14143223131 0023633 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckErrorStrings/CheckErrorStrings.go 0000664 0000000 0000000 00000001533 14143223131 0027565 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
import "errors"
func fn() {
errors.New("a perfectly fine error")
errors.New("Not a great error") // want `error strings should not be capitalized`
errors.New("also not a great error.") // want `error strings should not end with punctuation or a newline`
errors.New("URL is okay")
errors.New("SomeFunc is okay")
errors.New("URL is okay, but the period is not.") // want `error strings should not end with punctuation or a newline`
errors.New("T must not be nil")
errors.New("Foo() failed")
errors.New("Foo(bar) failed")
errors.New("Foo(bar, baz) failed")
}
func Write() {
errors.New("Write: this is broken")
}
type T struct{}
func (T) Read() {
errors.New("Read: this is broken")
errors.New("Read failed")
}
func fn2() {
// The error string hasn't to be in the same function
errors.New("Read failed")
}
go-tools-2021.1.2/stylecheck/testdata/src/CheckErrorVarNames/ 0000775 0000000 0000000 00000000000 14143223131 0023716 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckErrorVarNames/CheckErrorVarNames.go 0000664 0000000 0000000 00000001265 14143223131 0027735 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
import (
"errors"
"fmt"
)
var (
foo = errors.New("") // want `error var foo should have name of the form errFoo`
errBar = errors.New("")
qux, fisk, errAnother = errors.New(""), errors.New(""), errors.New("") // want `error var qux should have name of the form errFoo` `error var fisk should have name of the form errFoo`
abc = fmt.Errorf("") // want `error var abc should have name of the form errFoo`
errAbc = fmt.Errorf("")
)
var wrong = errors.New("") // want `error var wrong should have name of the form errFoo`
var result = fn()
func fn() error { return nil }
go-tools-2021.1.2/stylecheck/testdata/src/CheckExportedFunctionDocs/ 0000775 0000000 0000000 00000000000 14143223131 0025301 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckExportedFunctionDocs/CheckExportedFunctionDocs.go 0000664 0000000 0000000 00000001450 14143223131 0032677 0 ustar 00root root 0000000 0000000 package pkg
// whatever
func foo() {}
// Foo is amazing
func Foo() {}
// Whatever // want `comment on exported function`
func Bar() {}
type T struct{}
// Whatever
func (T) foo() {}
// Foo is amazing
func (T) Foo() {}
// Whatever // want `comment on exported method`
func (T) Bar() {}
//
func Qux() {} // this is fine, because "no comment" and "empty comment" are treated the same
//
// Meow is amazing.
//
// godoc allows this style, because ast.CommentGroup.Text strips whitespace.
// We currently make no effort to flag it.
//
func Meow() {}
//some:directive
func F1() {} // we pretend that directives aren't part of the doc string, just like godoc in Go 1.15+ does
//some:directive
// F2 is amazing
func F2() {}
//some:directive // want `comment on exported function`
// Whatever
func F3() {}
go-tools-2021.1.2/stylecheck/testdata/src/CheckExportedFunctionDocs/foo_test.go 0000664 0000000 0000000 00000000117 14143223131 0027451 0 ustar 00root root 0000000 0000000 package pkg
import "testing"
// This is a test
func TestFoo(t *testing.T) {}
go-tools-2021.1.2/stylecheck/testdata/src/CheckExportedTypeDocs/ 0000775 0000000 0000000 00000000000 14143223131 0024435 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckExportedTypeDocs/CheckExportedTypeDocs.go 0000664 0000000 0000000 00000001670 14143223131 0031173 0 ustar 00root root 0000000 0000000 package pkg
// Some type
type t1 struct{}
// Some type // want `comment on exported type`
type T2 struct{}
// T3 is amazing
type T3 struct{}
type (
// Some type // want `comment on exported type`
T4 struct{}
// The T5 type is amazing
T5 struct{}
// Some type
t6 struct{}
)
// Some types
type (
T7 struct{}
T8 struct{}
)
// Some types
type (
T9 struct{}
)
func fn() {
// Some type
type T1 struct{}
}
//
type T10 struct{} // this is fine, because "no comment" and "empty comment" are treated the same
//
// T11 is amazing.
//
// godoc allows this style, because ast.CommentGroup.Text strips whitespace.
// We currently make no effort to flag it.
//
type T11 struct{}
//some:directive
type T12 struct{} // we pretend that directives aren't part of the doc string, just like godoc in Go 1.15+ does
//some:directive
// T13 is amazing
type T13 struct{}
//some:directive // want `comment on exported type`
// Whatever
type T14 struct{}
go-tools-2021.1.2/stylecheck/testdata/src/CheckExportedVarDocs/ 0000775 0000000 0000000 00000000000 14143223131 0024244 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckExportedVarDocs/CheckExportedVarDocs.go 0000664 0000000 0000000 00000001231 14143223131 0030602 0 ustar 00root root 0000000 0000000 package pkg
// Whatever
var a int
// Whatever // want `should be of the form`
var B int
// Whatever
var (
// Whatever
C int
)
func fn() {
// Whatever
var D int
_ = D
}
//
var E int // this is fine, because "no comment" and "empty comment" are treated the same
//
// F is amazing.
//
// godoc allows this style, because ast.CommentGroup.Text strips whitespace.
// We currently make no effort to flag it.
//
var F int
//some:directive
var G int // we pretend that directives aren't part of the doc string, just like godoc in Go 1.15+ does
//some:directive
// H is amazing
var H int
//some:directive // want `should be of the form`
// Whatever
var I int
go-tools-2021.1.2/stylecheck/testdata/src/CheckHTTPStatusCodes/ 0000775 0000000 0000000 00000000000 14143223131 0024131 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckHTTPStatusCodes/CheckHTTPStatusCodes.go 0000664 0000000 0000000 00000001316 14143223131 0030360 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
import "net/http"
func fn() {
// Check all the supported functions
http.Error(nil, "", 506) // want `http\.StatusVariantAlsoNegotiates`
http.Redirect(nil, nil, "", 506) // want `http\.StatusVariantAlsoNegotiates`
http.StatusText(506) // want `http\.StatusVariantAlsoNegotiates`
http.RedirectHandler("", 506) // want `http\.StatusVariantAlsoNegotiates`
// Don't flag literals with no known constant
http.StatusText(600)
// Don't flag constants
http.StatusText(http.StatusAccepted)
// Don't flag items on the whitelist (well known codes)
http.StatusText(404)
http.Error(fn2())
}
func fn2() (http.ResponseWriter, string, int) { return nil, "", 0 }
go-tools-2021.1.2/stylecheck/testdata/src/CheckHTTPStatusCodes/CheckHTTPStatusCodes.go.golden 0000664 0000000 0000000 00000001502 14143223131 0031624 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
import "net/http"
func fn() {
// Check all the supported functions
http.Error(nil, "", http.StatusVariantAlsoNegotiates) // want `http\.StatusVariantAlsoNegotiates`
http.Redirect(nil, nil, "", http.StatusVariantAlsoNegotiates) // want `http\.StatusVariantAlsoNegotiates`
http.StatusText(http.StatusVariantAlsoNegotiates) // want `http\.StatusVariantAlsoNegotiates`
http.RedirectHandler("", http.StatusVariantAlsoNegotiates) // want `http\.StatusVariantAlsoNegotiates`
// Don't flag literals with no known constant
http.StatusText(600)
// Don't flag constants
http.StatusText(http.StatusAccepted)
// Don't flag items on the whitelist (well known codes)
http.StatusText(404)
http.Error(fn2())
}
func fn2() (http.ResponseWriter, string, int) { return nil, "", 0 }
go-tools-2021.1.2/stylecheck/testdata/src/CheckIncDec.disabled/ 0000775 0000000 0000000 00000000000 14143223131 0024063 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckIncDec.disabled/CheckIncDec.go 0000664 0000000 0000000 00000000300 14143223131 0026466 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
func fn() {
var x int
x--
x++
x += 1 // want `should replace x \+= 1 with x\+\+`
x -= 1 // want `should replace x -= 1 with x--`
x /= 1
x += 2
x -= 2
}
go-tools-2021.1.2/stylecheck/testdata/src/CheckInvisibleCharacters/ 0000775 0000000 0000000 00000000000 14143223131 0025114 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckInvisibleCharacters/CheckInvisibleCharacters.go 0000664 0000000 0000000 00000000370 14143223131 0032325 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
var (
a = "" // want `Unicode control character U\+0007`
b = "" // want `Unicode control characters`
c = "Test test"
d = `T
est`
e = `ZeroβWidth` // want `Unicode format character U\+200B`
f = "\u200b"
)
CheckInvisibleCharacters.go.golden 0000664 0000000 0000000 00000000403 14143223131 0033512 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckInvisibleCharacters // Package pkg ...
package pkg
var (
a = "\a" // want `Unicode control character U\+0007`
b = "\a\x1a" // want `Unicode control characters`
c = "Test test"
d = `T
est`
e = `Zero\u200bWidth` // want `Unicode format character U\+200B`
f = "\u200b"
)
go-tools-2021.1.2/stylecheck/testdata/src/CheckNames/ 0000775 0000000 0000000 00000000000 14143223131 0022233 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckNames/CheckNames.go 0000664 0000000 0000000 00000002553 14143223131 0024570 0 ustar 00root root 0000000 0000000 // Package pkg_foo ...
package pkg_foo // want `should not use underscores in package names`
var range_ int
var _abcdef int
var abcdef_ int
var abc_def int // want `should not use underscores in Go names; var abc_def should be abcDef`
var abc_def_ int // want `should not use underscores in Go names; var abc_def_ should be abcDef_`
func fn_1() {} // want `func fn_1 should be fn1`
func fn2() {}
func fn_Id() {} // want `func fn_Id should be fnID`
func fnId() {} // want `func fnId should be fnID`
var FOO_BAR int // want `should not use ALL_CAPS in Go names; use CamelCase instead`
var Foo_BAR int // want `var Foo_BAR should be FooBAR`
var foo_bar int // want `foo_bar should be fooBar`
var kFoobar int // not a check we inherited from golint. more false positives than true ones.
var _1000 int // issue 858
func fn(x []int) {
var (
a_b = 1 // want `var a_b should be aB`
c_d int // want `var c_d should be cD`
)
a_b += 2
for e_f := range x { // want `range var e_f should be eF`
_ = e_f
}
_ = a_b
_ = c_d
}
//export fn_3
func fn_3() {}
//export not actually the export keyword
func fn_4() {} // want `func fn_4 should be fn4`
//export
func fn_5() {} // want `func fn_5 should be fn5`
// export fn_6
func fn_6() {} // want `func fn_6 should be fn6`
//export fn_8
func fn_7() {} // want `func fn_7 should be fn7`
//go:linkname fn_8 time.Now
func fn_8() {}
go-tools-2021.1.2/stylecheck/testdata/src/CheckNames_generated/ 0000775 0000000 0000000 00000000000 14143223131 0024251 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckNames_generated/CheckNames_generated.go 0000664 0000000 0000000 00000000133 14143223131 0030614 0 ustar 00root root 0000000 0000000 // Code generated by an actual human. DO NOT EDIT.
// Package pkg_foo ...
package pkg_foo
go-tools-2021.1.2/stylecheck/testdata/src/CheckPackageComment-1/ 0000775 0000000 0000000 00000000000 14143223131 0024204 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckPackageComment-1/CheckPackageComment-1.go 0000664 0000000 0000000 00000000123 14143223131 0030501 0 ustar 00root root 0000000 0000000 package pkg // want `at least one file in a package should have a package comment`
go-tools-2021.1.2/stylecheck/testdata/src/CheckPackageComment-2/ 0000775 0000000 0000000 00000000000 14143223131 0024205 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckPackageComment-2/CheckPackageComment-2.go 0000664 0000000 0000000 00000000125 14143223131 0030505 0 ustar 00root root 0000000 0000000 // This package is great // want `package comment should be of the form`
package pkg
go-tools-2021.1.2/stylecheck/testdata/src/CheckPackageComment-3/ 0000775 0000000 0000000 00000000000 14143223131 0024206 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckPackageComment-3/CheckPackageComment-3.go 0000664 0000000 0000000 00000000054 14143223131 0030510 0 ustar 00root root 0000000 0000000 /*
Package pkg is useful.
*/
package pkg
go-tools-2021.1.2/stylecheck/testdata/src/CheckReceiverNames/ 0000775 0000000 0000000 00000000000 14143223131 0023720 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckReceiverNames/CheckReceiverNames.go 0000664 0000000 0000000 00000000517 14143223131 0027740 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
type T1 int
func (x T1) Fn1() {}
func (y T1) Fn2() {}
func (x T1) Fn3() {}
func (T1) Fn4() {}
func (_ T1) Fn5() {} // want `receiver name should not be an underscore, omit the name if it is unused`
func (self T1) Fn6() {} // want `receiver name should be a reflection of its identity`
go-tools-2021.1.2/stylecheck/testdata/src/CheckReceiverNamesIdentical/ 0000775 0000000 0000000 00000000000 14143223131 0025535 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckReceiverNamesIdentical/CheckReceiverNames.go 0000664 0000000 0000000 00000000552 14143223131 0031554 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
type T1 int
func (x T1) Fn1() {} // want `methods on the same type should have the same receiver name`
func (y T1) Fn2() {}
func (x T1) Fn3() {}
func (T1) Fn4() {}
func (_ T1) Fn5() {}
func (self T1) Fn6() {}
func (bar T3) Fn2() {} // want `1x "bar", 1x "meow"`
func (meow T3) Fn3() {}
func (bar T4) Fn2() {}
go-tools-2021.1.2/stylecheck/testdata/src/CheckReceiverNamesIdentical/generated.go 0000664 0000000 0000000 00000000516 14143223131 0030024 0 ustar 00root root 0000000 0000000 // Code generated by hand. DO NOT EDIT.
package pkg
// Methods on T2 are only defined in this generated file
// Methods on T3 and T4 are defined in this file and a non-generated file
type T2 struct{}
func (foo T2) Fn1() {}
func (bar T2) Fn2() {}
type T3 struct{}
func (foo T3) Fn1() {}
type T4 struct{}
func (foo T4) Fn1() {}
go-tools-2021.1.2/stylecheck/testdata/src/CheckRedundantTypeInDeclaration/ 0000775 0000000 0000000 00000000000 14143223131 0026413 5 ustar 00root root 0000000 0000000 CheckRedundantTypeInDeclaration.go 0000664 0000000 0000000 00000001773 14143223131 0035054 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckRedundantTypeInDeclaration package pkg
import (
"io"
"math"
)
type MyInt int
const X int = 1
const Y = 1
func gen1() int { return 0 }
func gen2() io.ReadCloser { return nil }
func gen3() MyInt { return 0 }
// don't flag global variables
var a int = gen1()
func fn() {
var _ int = gen1() // don't flag blank identifier
var a int = Y // don't flag named untyped constants
var b int = 1 // want `should omit type int`
var c int = 1.0 // different default type
var d MyInt = 1 // different default type
var e io.ReadCloser = gen2() // want `should omit type io.ReadCloser`
var f io.Reader = gen2() // different interface type
var g float64 = math.Pi // don't flag named untyped constants
var h bool = true // want `should omit type bool`
var i string = "" // want `should omit type string`
var j MyInt = gen3() // want `should omit type MyInt`
_, _, _, _, _, _, _, _, _, _ = a, b, c, d, e, f, g, h, i, j
}
CheckRedundantTypeInDeclaration.go.golden 0000664 0000000 0000000 00000001717 14143223131 0036321 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckRedundantTypeInDeclaration package pkg
import (
"io"
"math"
)
type MyInt int
const X int = 1
const Y = 1
func gen1() int { return 0 }
func gen2() io.ReadCloser { return nil }
func gen3() MyInt { return 0 }
// don't flag global variables
var a int = gen1()
func fn() {
var _ int = gen1() // don't flag blank identifier
var a int = Y // don't flag named untyped constants
var b = 1 // want `should omit type int`
var c int = 1.0 // different default type
var d MyInt = 1 // different default type
var e = gen2() // want `should omit type io.ReadCloser`
var f io.Reader = gen2() // different interface type
var g float64 = math.Pi // don't flag named untyped constants
var h = true // want `should omit type bool`
var i = "" // want `should omit type string`
var j = gen3() // want `should omit type MyInt`
_, _, _, _, _, _, _, _, _, _ = a, b, c, d, e, f, g, h, i, j
}
go-tools-2021.1.2/stylecheck/testdata/src/CheckRedundantTypeInDeclaration_syscall/ 0000775 0000000 0000000 00000000000 14143223131 0030145 5 ustar 00root root 0000000 0000000 CheckRedundantTypeInDeclaration_syscall.go 0000664 0000000 0000000 00000000165 14143223131 0040332 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckRedundantTypeInDeclaration_syscall package pkg
import _ "syscall"
func fn() {
// not flagged because we're importing syscall
var x int = 1
_ = x
}
go-tools-2021.1.2/stylecheck/testdata/src/CheckTimeNames/ 0000775 0000000 0000000 00000000000 14143223131 0023052 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckTimeNames/CheckTimeNames.go 0000664 0000000 0000000 00000001303 14143223131 0026216 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
import "time"
type T1 struct {
aMS int
B time.Duration
BMillis time.Duration // want `don't use unit-specific suffix`
}
func fn1(a, b, cMS time.Duration) { // want `don't use unit-specific suffix`
var x time.Duration
var xMS time.Duration // want `don't use unit-specific suffix`
var y, yMS time.Duration // want `don't use unit-specific suffix`
var zMS = time.Second // want `don't use unit-specific suffix`
aMS := time.Second // want `don't use unit-specific suffix`
unrelated, aMS := 0, 0
aMS, bMS := 0, time.Second // want `var bMS .+ don't use unit-specific suffix`
_, _, _, _, _, _, _, _ = x, xMS, y, yMS, zMS, aMS, unrelated, bMS
}
go-tools-2021.1.2/stylecheck/testdata/src/CheckYodaConditions/ 0000775 0000000 0000000 00000000000 14143223131 0024116 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/CheckYodaConditions/CheckYodaConditions.go 0000664 0000000 0000000 00000000311 14143223131 0030324 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
func fn(x string, y int) {
if "" == x { // want `Yoda`
}
if 0 == y { // want `Yoda`
}
if 0 > y {
}
if "" == "" {
}
if "" == "" || 0 == y { // want `Yoda`
}
}
go-tools-2021.1.2/stylecheck/testdata/src/CheckYodaConditions/CheckYodaConditions.go.golden 0000664 0000000 0000000 00000000311 14143223131 0031573 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
func fn(x string, y int) {
if x == "" { // want `Yoda`
}
if y == 0 { // want `Yoda`
}
if 0 > y {
}
if "" == "" {
}
if "" == "" || y == 0 { // want `Yoda`
}
}
go-tools-2021.1.2/stylecheck/testdata/src/_CheckBlankImports.disabled/ 0000775 0000000 0000000 00000000000 14143223131 0025502 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/_CheckBlankImports.disabled/CheckBlankImports-2.go 0000664 0000000 0000000 00000001230 14143223131 0031527 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
import _ "fmt" // want `blank import`
import _ "fmt" // want `blank import`
import _ "fmt"
import _ "fmt"
import _ "fmt" // want `blank import`
import "strings"
import _ "fmt" // want `blank import`
// This is fine
import _ "fmt"
// This is fine
import _ "fmt"
import _ "fmt"
import _ "fmt"
// This is fine
import _ "fmt"
import "bytes"
import _ "fmt" // want `blank import`
import _ "fmt" // This is fine
// This is not fine
import (
_ "fmt" // want `blank import`
)
import (
_ "fmt" // want `blank import`
"strconv"
// This is fine
_ "fmt"
)
var _ = strings.NewReader
var _ = bytes.NewBuffer
var _ = strconv.IntSize
go-tools-2021.1.2/stylecheck/testdata/src/_CheckBlankImports.disabled/CheckBlankImports_test.go 0000664 0000000 0000000 00000000057 14143223131 0032435 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
import _ "fmt"
go-tools-2021.1.2/stylecheck/testdata/src/_CheckUnexportedReturn.disabled/ 0000775 0000000 0000000 00000000000 14143223131 0026432 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/_CheckUnexportedReturn.disabled/CheckUnexportedReturn.go 0000664 0000000 0000000 00000001217 14143223131 0033255 0 ustar 00root root 0000000 0000000 // Package pkg ...
package pkg
type t1 int
type T2 int
type Recv int
type recv int
func fn1() string { return "" }
func Fn2() error { return nil }
func fn3() error { return nil }
func fn5() t1 { return 0 }
func Fn6() t1 { return 0 } // want `should not return unexported type`
func Fn7() *t1 { return nil } // want `should not return unexported type`
func Fn8() T2 { return 0 }
func (Recv) fn9() t1 { return 0 }
func (Recv) Fn10() t1 { return 0 } // want `should not return unexported type`
func (Recv) Fn11() T2 { return 0 }
func (recv) fn9() t1 { return 0 }
func (recv) Fn10() t1 { return 0 }
func (recv) Fn11() T2 { return 0 }
CheckUnexportedReturn_test.go 0000664 0000000 0000000 00000000213 14143223131 0034230 0 ustar 00root root 0000000 0000000 go-tools-2021.1.2/stylecheck/testdata/src/_CheckUnexportedReturn.disabled // Package pkg ...
package pkg
func Fn13() t1 { return 0 }
func Fn14() *t1 { return nil }
func (Recv) Fn15() t1 { return 0 }
go-tools-2021.1.2/unused/ 0000775 0000000 0000000 00000000000 14143223131 0014777 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/edge.go 0000664 0000000 0000000 00000001725 14143223131 0016237 0 ustar 00root root 0000000 0000000 package unused
//go:generate stringer -type edgeKind
type edgeKind uint64
func (e edgeKind) is(o edgeKind) bool {
return e&o != 0
}
const (
edgeAlias edgeKind = 1 << iota
edgeBlankField
edgeAnonymousStruct
edgeCgoExported
edgeConstGroup
edgeElementType
edgeEmbeddedInterface
edgeExportedConstant
edgeExportedField
edgeExportedFunction
edgeExportedMethod
edgeExportedType
edgeExportedVariable
edgeExtendsExportedFields
edgeExtendsExportedMethodSet
edgeFieldAccess
edgeFunctionArgument
edgeFunctionResult
edgeFunctionSignature
edgeImplements
edgeInstructionOperand
edgeInterfaceCall
edgeInterfaceMethod
edgeKeyType
edgeLinkname
edgeMainFunction
edgeNamedType
edgeNetRPCRegister
edgeNoCopySentinel
edgeProvidesMethod
edgeReceiver
edgeRuntimeFunction
edgeSignature
edgeStructConversion
edgeTestSink
edgeTupleElement
edgeType
edgeTypeName
edgeUnderlyingType
edgePointerType
edgeUnsafeConversion
edgeUsedConstant
edgeVarDecl
edgeIgnored
)
go-tools-2021.1.2/unused/edgekind_string.go 0000664 0000000 0000000 00000010463 14143223131 0020472 0 ustar 00root root 0000000 0000000 // Code generated by "stringer -type edgeKind"; DO NOT EDIT.
package unused
import "strconv"
func _() {
// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
var x [1]struct{}
_ = x[edgeAlias-1]
_ = x[edgeBlankField-2]
_ = x[edgeAnonymousStruct-4]
_ = x[edgeCgoExported-8]
_ = x[edgeConstGroup-16]
_ = x[edgeElementType-32]
_ = x[edgeEmbeddedInterface-64]
_ = x[edgeExportedConstant-128]
_ = x[edgeExportedField-256]
_ = x[edgeExportedFunction-512]
_ = x[edgeExportedMethod-1024]
_ = x[edgeExportedType-2048]
_ = x[edgeExportedVariable-4096]
_ = x[edgeExtendsExportedFields-8192]
_ = x[edgeExtendsExportedMethodSet-16384]
_ = x[edgeFieldAccess-32768]
_ = x[edgeFunctionArgument-65536]
_ = x[edgeFunctionResult-131072]
_ = x[edgeFunctionSignature-262144]
_ = x[edgeImplements-524288]
_ = x[edgeInstructionOperand-1048576]
_ = x[edgeInterfaceCall-2097152]
_ = x[edgeInterfaceMethod-4194304]
_ = x[edgeKeyType-8388608]
_ = x[edgeLinkname-16777216]
_ = x[edgeMainFunction-33554432]
_ = x[edgeNamedType-67108864]
_ = x[edgeNetRPCRegister-134217728]
_ = x[edgeNoCopySentinel-268435456]
_ = x[edgeProvidesMethod-536870912]
_ = x[edgeReceiver-1073741824]
_ = x[edgeRuntimeFunction-2147483648]
_ = x[edgeSignature-4294967296]
_ = x[edgeStructConversion-8589934592]
_ = x[edgeTestSink-17179869184]
_ = x[edgeTupleElement-34359738368]
_ = x[edgeType-68719476736]
_ = x[edgeTypeName-137438953472]
_ = x[edgeUnderlyingType-274877906944]
_ = x[edgePointerType-549755813888]
_ = x[edgeUnsafeConversion-1099511627776]
_ = x[edgeUsedConstant-2199023255552]
_ = x[edgeVarDecl-4398046511104]
}
const _edgeKind_name = "edgeAliasedgeBlankFieldedgeAnonymousStructedgeCgoExportededgeConstGroupedgeElementTypeedgeEmbeddedInterfaceedgeExportedConstantedgeExportedFieldedgeExportedFunctionedgeExportedMethodedgeExportedTypeedgeExportedVariableedgeExtendsExportedFieldsedgeExtendsExportedMethodSetedgeFieldAccessedgeFunctionArgumentedgeFunctionResultedgeFunctionSignatureedgeImplementsedgeInstructionOperandedgeInterfaceCalledgeInterfaceMethodedgeKeyTypeedgeLinknameedgeMainFunctionedgeNamedTypeedgeNetRPCRegisteredgeNoCopySentineledgeProvidesMethodedgeReceiveredgeRuntimeFunctionedgeSignatureedgeStructConversionedgeTestSinkedgeTupleElementedgeTypeedgeTypeNameedgeUnderlyingTypeedgePointerTypeedgeUnsafeConversionedgeUsedConstantedgeVarDecl"
var _edgeKind_map = map[edgeKind]string{
1: _edgeKind_name[0:9],
2: _edgeKind_name[9:23],
4: _edgeKind_name[23:42],
8: _edgeKind_name[42:57],
16: _edgeKind_name[57:71],
32: _edgeKind_name[71:86],
64: _edgeKind_name[86:107],
128: _edgeKind_name[107:127],
256: _edgeKind_name[127:144],
512: _edgeKind_name[144:164],
1024: _edgeKind_name[164:182],
2048: _edgeKind_name[182:198],
4096: _edgeKind_name[198:218],
8192: _edgeKind_name[218:243],
16384: _edgeKind_name[243:271],
32768: _edgeKind_name[271:286],
65536: _edgeKind_name[286:306],
131072: _edgeKind_name[306:324],
262144: _edgeKind_name[324:345],
524288: _edgeKind_name[345:359],
1048576: _edgeKind_name[359:381],
2097152: _edgeKind_name[381:398],
4194304: _edgeKind_name[398:417],
8388608: _edgeKind_name[417:428],
16777216: _edgeKind_name[428:440],
33554432: _edgeKind_name[440:456],
67108864: _edgeKind_name[456:469],
134217728: _edgeKind_name[469:487],
268435456: _edgeKind_name[487:505],
536870912: _edgeKind_name[505:523],
1073741824: _edgeKind_name[523:535],
2147483648: _edgeKind_name[535:554],
4294967296: _edgeKind_name[554:567],
8589934592: _edgeKind_name[567:587],
17179869184: _edgeKind_name[587:599],
34359738368: _edgeKind_name[599:615],
68719476736: _edgeKind_name[615:623],
137438953472: _edgeKind_name[623:635],
274877906944: _edgeKind_name[635:653],
549755813888: _edgeKind_name[653:668],
1099511627776: _edgeKind_name[668:688],
2199023255552: _edgeKind_name[688:704],
4398046511104: _edgeKind_name[704:715],
}
func (i edgeKind) String() string {
if str, ok := _edgeKind_map[i]; ok {
return str
}
return "edgeKind(" + strconv.FormatInt(int64(i), 10) + ")"
}
go-tools-2021.1.2/unused/implements.go 0000664 0000000 0000000 00000003722 14143223131 0017507 0 ustar 00root root 0000000 0000000 package unused
import "go/types"
// lookupMethod returns the index of and method with matching package and name, or (-1, nil).
func lookupMethod(T *types.Interface, pkg *types.Package, name string) (int, *types.Func) {
if name != "_" {
for i := 0; i < T.NumMethods(); i++ {
m := T.Method(i)
if sameId(m, pkg, name) {
return i, m
}
}
}
return -1, nil
}
func sameId(obj types.Object, pkg *types.Package, name string) bool {
// spec:
// "Two identifiers are different if they are spelled differently,
// or if they appear in different packages and are not exported.
// Otherwise, they are the same."
if name != obj.Name() {
return false
}
// obj.Name == name
if obj.Exported() {
return true
}
// not exported, so packages must be the same (pkg == nil for
// fields in Universe scope; this can only happen for types
// introduced via Eval)
if pkg == nil || obj.Pkg() == nil {
return pkg == obj.Pkg()
}
// pkg != nil && obj.pkg != nil
return pkg.Path() == obj.Pkg().Path()
}
func (g *graph) implements(V types.Type, T *types.Interface, msV *types.MethodSet) ([]*types.Selection, bool) {
// fast path for common case
if T.Empty() {
return nil, true
}
if ityp, _ := V.Underlying().(*types.Interface); ityp != nil {
// TODO(dh): is this code reachable?
for i := 0; i < T.NumMethods(); i++ {
m := T.Method(i)
_, obj := lookupMethod(ityp, m.Pkg(), m.Name())
switch {
case obj == nil:
return nil, false
case !types.Identical(obj.Type(), m.Type()):
return nil, false
}
}
return nil, true
}
// A concrete type implements T if it implements all methods of T.
var sels []*types.Selection
for i := 0; i < T.NumMethods(); i++ {
m := T.Method(i)
sel := msV.Lookup(m.Pkg(), m.Name())
if sel == nil {
return nil, false
}
f, _ := sel.Obj().(*types.Func)
if f == nil {
return nil, false
}
if !types.Identical(f.Type(), m.Type()) {
return nil, false
}
sels = append(sels, sel)
}
return sels, true
}
go-tools-2021.1.2/unused/testdata/ 0000775 0000000 0000000 00000000000 14143223131 0016610 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/ 0000775 0000000 0000000 00000000000 14143223131 0017377 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/alias/ 0000775 0000000 0000000 00000000000 14143223131 0020470 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/alias/alias.go 0000664 0000000 0000000 00000001265 14143223131 0022114 0 ustar 00root root 0000000 0000000 package main
import "net/http"
type t1 struct{} // used
type t2 struct{} // unused
type t3 struct{} // used
type alias1 = t1 // used
type alias2 = t2 // unused
type alias3 = t3 // used
type alias4 = int // used
func main() { // used
var _ alias1
var _ t3
}
type t4 struct { // used
x int // used
}
func (t4) foo() {} // used
//lint:ignore U1000 alias5 is ignored, which also ignores t4
type alias5 = t4 // used
//lint:ignore U1000 alias6 is ignored, and we don't incorrectly try to include http.Server's fields and methods in the graph
type alias6 = http.Server // used
//lint:ignore U1000 aliases don't have to be to named types
type alias7 = struct { // used
x int // used
}
go-tools-2021.1.2/unused/testdata/src/anonymous/ 0000775 0000000 0000000 00000000000 14143223131 0021427 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/anonymous/anonymous.go 0000664 0000000 0000000 00000000411 14143223131 0024002 0 ustar 00root root 0000000 0000000 package pkg
import "fmt"
type Node interface { // used
position() int // used
}
type noder struct{} // used
func (noder) position() int { panic("unreachable") } // used
func Fn() { // used
nodes := []Node{struct {
noder // used
}{}}
fmt.Println(nodes)
}
go-tools-2021.1.2/unused/testdata/src/blank/ 0000775 0000000 0000000 00000000000 14143223131 0020466 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/blank/blank.go 0000664 0000000 0000000 00000000550 14143223131 0022104 0 ustar 00root root 0000000 0000000 package pkg
import _ "fmt"
type t1 struct{} // unused
type t2 struct { // used
_ int // used
}
type t3 struct{} // used
type t4 struct{} // used
type t5 struct{} // used
var _ = t2{}
func fn1() { // unused
_ = t1{}
var _ = t1{}
}
func fn2() { // used
_ = t3{}
var _ t4
var _ *t5 = nil
}
func init() { // used
fn2()
}
func _() {}
type _ struct{}
go-tools-2021.1.2/unused/testdata/src/cgo/ 0000775 0000000 0000000 00000000000 14143223131 0020147 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/cgo/cgo.go 0000664 0000000 0000000 00000000124 14143223131 0021243 0 ustar 00root root 0000000 0000000 package pkg
//go:cgo_export_dynamic
func foo() {} // used
func bar() {} // unused
go-tools-2021.1.2/unused/testdata/src/consts/ 0000775 0000000 0000000 00000000000 14143223131 0020710 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/consts/consts.go 0000664 0000000 0000000 00000000627 14143223131 0022555 0 ustar 00root root 0000000 0000000 package pkg
const c1 = 1 // used
const c2 = 1 // used
const c3 = 1 // used
const c4 = 1 // used
const C5 = 1 // used
const (
c6 = 0 // used
c7 // used
c8 // used
c9 // unused
c10 // unused
c11 // unused
)
var _ = []int{c3: 1}
type T1 struct { // used
F1 [c1]int // used
}
func init() { // used
_ = []int{c2: 1}
var _ [c4]int
_ = c7
}
func Fn() { // used
const X = 1 // unused
}
go-tools-2021.1.2/unused/testdata/src/conversion/ 0000775 0000000 0000000 00000000000 14143223131 0021564 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/conversion/conversion.go 0000664 0000000 0000000 00000002267 14143223131 0024307 0 ustar 00root root 0000000 0000000 package pkg
import (
"compress/flate"
"unsafe"
)
type t1 struct { // used
a int // used
b int // used
}
type t2 struct { // used
a int // used
b int // used
}
type t3 struct { // used
a int // used
b int // unused
}
type t4 struct { // used
a int // used
b int // unused
}
type t5 struct { // used
a int // used
b int // used
}
type t6 struct { // used
a int // used
b int // used
}
type t7 struct { // used
a int // used
b int // used
}
type t8 struct { // used
a int // used
b int // used
}
type t9 struct { // used
Offset int64 // used
Err error // used
}
type t10 struct { // used
a int // used
b int // used
}
func fn() { // used
// All fields in t2 used because they're initialised in t1
v1 := t1{0, 1}
v2 := t2(v1)
_ = v2
// Field b isn't used by anyone
v3 := t3{}
v4 := t4(v3)
println(v3.a)
_ = v4
// Both fields are used
v5 := t5{}
v6 := t6(v5)
println(v5.a)
println(v6.b)
v7 := &t7{}
println(v7.a)
println(v7.b)
v8 := (*t8)(v7)
_ = v8
vb := flate.ReadError{}
v9 := t9(vb)
_ = v9
// All fields are used because this is an unsafe conversion
var b []byte
v10 := (*t10)(unsafe.Pointer(&b[0]))
_ = v10
}
func init() { fn() } // used
go-tools-2021.1.2/unused/testdata/src/cyclic/ 0000775 0000000 0000000 00000000000 14143223131 0020645 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/cyclic/cyclic.go 0000664 0000000 0000000 00000000106 14143223131 0022437 0 ustar 00root root 0000000 0000000 package pkg
func a() { // unused
b()
}
func b() { // unused
a()
}
go-tools-2021.1.2/unused/testdata/src/defer/ 0000775 0000000 0000000 00000000000 14143223131 0020464 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/defer/defer.go 0000664 0000000 0000000 00000000340 14143223131 0022075 0 ustar 00root root 0000000 0000000 package pkg
type t struct{} // used
func (t) fn1() {} // used
func (t) fn2() {} // used
func fn1() {} // used
func fn2() {} // used
func Fn() { // used
var v t
defer fn1()
defer v.fn1()
go fn2()
go v.fn2()
}
go-tools-2021.1.2/unused/testdata/src/elem/ 0000775 0000000 0000000 00000000000 14143223131 0020321 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/elem/elem.go 0000664 0000000 0000000 00000000376 14143223131 0021600 0 ustar 00root root 0000000 0000000 // Test of field usage detection
package pkg
type t15 struct { // used
f151 int // used
}
type a2 [1]t15 // used
type t16 struct{} // used
type a3 [1][1]t16 // used
func foo() { // used
_ = a2{0: {1}}
_ = a3{{{}}}
}
func init() { foo() } // used
go-tools-2021.1.2/unused/testdata/src/embedded_call/ 0000775 0000000 0000000 00000000000 14143223131 0022123 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/embedded_call/embedded_call.go 0000664 0000000 0000000 00000000510 14143223131 0025172 0 ustar 00root root 0000000 0000000 package pkg
var t1 struct { // used
t2 // used
t3 // used
t4 // used
}
type t2 struct{} // used
type t3 struct{} // used
type t4 struct { // used
t5 // used
}
type t5 struct{} // used
func (t2) foo() {} // used
func (t3) bar() {} // used
func (t5) baz() {} // used
func init() { // used
t1.foo()
_ = t1.bar
t1.baz()
}
go-tools-2021.1.2/unused/testdata/src/embedding/ 0000775 0000000 0000000 00000000000 14143223131 0021315 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/embedding/embedding.go 0000664 0000000 0000000 00000001771 14143223131 0023570 0 ustar 00root root 0000000 0000000 package pkg
type I interface { // used
f1() // used
f2() // used
}
func init() { // used
var _ I
}
type t1 struct{} // used
type T2 struct { // used
t1 // used
}
func (t1) f1() {} // used
func (T2) f2() {} // used
func Fn() { // used
var v T2
_ = v.t1
}
type I2 interface { // used
f3() // used
f4() // used
}
type t3 struct{} // used
type t4 struct { // used
x int // unused
y int // unused
t3 // used
}
func (*t3) f3() {} // used
func (*t4) f4() {} // used
func init() { // used
var i I2 = &t4{}
i.f3()
i.f4()
}
type i3 interface { // used
F() // used
}
type I4 interface { // used
i3
}
type T5 struct { // used
t6 // used
}
type t6 struct { // used
F int // used
}
type t7 struct { // used
X int // used
}
type t8 struct { // used
t7 // used
}
type t9 struct { // used
t8 // used
}
var _ = t9{}
type t10 struct{} // used
func (*t10) Foo() {} // used
type t11 struct { // used
t10 // used
}
var _ = t11{}
type i5 interface{} // used
type I6 interface { // used
i5
}
go-tools-2021.1.2/unused/testdata/src/embedding2/ 0000775 0000000 0000000 00000000000 14143223131 0021377 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/embedding2/embedding2.go 0000664 0000000 0000000 00000000462 14143223131 0023730 0 ustar 00root root 0000000 0000000 package main
type AA interface { // used
A() // used
}
type BB interface { // used
AA
}
type CC interface { // used
BB
C() // used
}
func c(cc CC) { // used
cc.A()
}
type z struct{} // used
func (z) A() {} // used
func (z) B() {} // used
func (z) C() {} // used
func main() { // used
c(z{})
}
go-tools-2021.1.2/unused/testdata/src/exported_fields/ 0000775 0000000 0000000 00000000000 14143223131 0022557 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/exported_fields/exported_fields.go 0000664 0000000 0000000 00000000640 14143223131 0026266 0 ustar 00root root 0000000 0000000 package pkg
type t1 struct { // used
F1 int // used
}
type T2 struct { // used
F2 int // used
}
var v struct { // used
T3 // used
}
type T3 struct{} // used
func (T3) Foo() {} // used
func init() { // used
v.Foo()
}
func init() { // used
_ = t1{}
}
type codeResponse struct { // used
Tree *codeNode `json:"tree"` // used
}
type codeNode struct { // used
}
func init() { // used
_ = codeResponse{}
}
go-tools-2021.1.2/unused/testdata/src/exported_fields_main/ 0000775 0000000 0000000 00000000000 14143223131 0023563 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/exported_fields_main/exported_fields_main.go 0000664 0000000 0000000 00000000222 14143223131 0030272 0 ustar 00root root 0000000 0000000 package main
type t1 struct { // used
F1 int // used
}
type T2 struct { // used
F2 int // used
}
func init() { // used
_ = t1{}
_ = T2{}
}
go-tools-2021.1.2/unused/testdata/src/exported_method_test/ 0000775 0000000 0000000 00000000000 14143223131 0023630 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/exported_method_test/exported_method.go 0000664 0000000 0000000 00000000014 14143223131 0027344 0 ustar 00root root 0000000 0000000 package pkg
go-tools-2021.1.2/unused/testdata/src/exported_method_test/exported_method_test.go 0000664 0000000 0000000 00000001262 14143223131 0030411 0 ustar 00root root 0000000 0000000 package pkg
import (
"bytes"
"io"
"io/ioutil"
"testing"
)
type countReadSeeker struct { // used_test
io.ReadSeeker // used_test
N int64 // used_test
}
func (rs *countReadSeeker) Read(buf []byte) (int, error) { // used_test
n, err := rs.ReadSeeker.Read(buf)
rs.N += int64(n)
return n, err
}
func TestFoo(t *testing.T) { // used_test
r := bytes.NewReader([]byte("Hello, world!"))
cr := &countReadSeeker{ReadSeeker: r}
ioutil.ReadAll(cr)
if cr.N != 13 {
t.Errorf("got %d, want 13", cr.N)
}
}
var sink int // used_test
func BenchmarkFoo(b *testing.B) { // used_test
for i := 0; i < b.N; i++ {
sink = fn()
}
}
func fn() int { return 0 } // used_test
go-tools-2021.1.2/unused/testdata/src/fields/ 0000775 0000000 0000000 00000000000 14143223131 0020645 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/fields/fields.go 0000664 0000000 0000000 00000003743 14143223131 0022451 0 ustar 00root root 0000000 0000000 // Test of field usage detection
package pkg
type t1 struct { // used
f11 int // used
f12 int // used
}
type t2 struct { // used
f21 int // used
f22 int // used
}
type t3 struct { // used
f31 t4 // used
}
type t4 struct { // used
f41 int // used
}
type t5 struct { // used
f51 int // used
}
type t6 struct { // used
f61 int // used
}
type t7 struct { // used
f71 int // used
}
type m1 map[string]t7 // used
type t8 struct { // used
f81 int // used
}
type t9 struct { // used
f91 int // used
}
type t10 struct { // used
f101 int // used
}
type t11 struct { // used
f111 int // used
}
type s1 []t11 // used
type t12 struct { // used
f121 int // used
}
type s2 []t12 // used
type t13 struct { // used
f131 int // used
}
type t14 struct { // used
f141 int // used
}
type a1 [1]t14 // used
type t15 struct { // used
f151 int // used
}
type a2 [1]t15 // used
type t16 struct { // used
f161 int // used
}
type t17 struct { // unused
f171 int
f172 int
}
type t18 struct { // used
f181 int // used
f182 int // unused
f183 int // unused
}
type t19 struct { // used
f191 int // used
}
type m2 map[string]t19 // used
type t20 struct { // used
f201 int // used
}
type m3 map[string]t20 // used
type t21 struct { // used
f211 int // unused
f212 int // used
}
type t22 struct { // unused
f221 int
f222 int
}
func foo() { // used
_ = t10{1}
_ = t21{f212: 1}
_ = []t1{{1, 2}}
_ = t2{1, 2}
_ = []struct {
a int // used
}{{1}}
// XXX
// _ = []struct{ foo struct{ bar int } }{{struct{ bar int }{1}}}
_ = []t1{t1{1, 2}}
_ = []t3{{t4{1}}}
_ = map[string]t5{"a": {1}}
_ = map[t6]string{{1}: "a"}
_ = m1{"a": {1}}
_ = map[t8]t8{{}: {1}}
_ = map[t9]t9{{1}: {}}
_ = s1{{1}}
_ = s2{2: {1}}
_ = [...]t13{{1}}
_ = a1{{1}}
_ = a2{0: {1}}
_ = map[[1]t16]int{{{1}}: 1}
y := struct {
x int // used
}{}
_ = y
_ = t18{f181: 1}
_ = []m2{{"a": {1}}}
_ = [][]m3{{{"a": {1}}}}
}
func init() { foo() } // used
func superUnused() { // unused
var _ struct {
x int
}
}
go-tools-2021.1.2/unused/testdata/src/functions/ 0000775 0000000 0000000 00000000000 14143223131 0021407 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/functions/functions.go 0000664 0000000 0000000 00000001005 14143223131 0023742 0 ustar 00root root 0000000 0000000 package main
type state func() state // used
func a() state { // used
return a
}
func main() { // used
st := a
_ = st()
}
type t1 struct{} // unused
type t2 struct{} // used
type t3 struct{} // used
func fn1() t1 { return t1{} } // unused
func fn2() (x t2) { return } // used
func fn3() *t3 { return nil } // used
func fn4() { // used
const x = 1 // used
const y = 2 // unused
type foo int // unused
type bar int // used
_ = x
_ = bar(0)
}
func init() { // used
fn2()
fn3()
fn4()
}
go-tools-2021.1.2/unused/testdata/src/ignored/ 0000775 0000000 0000000 00000000000 14143223131 0021026 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/ignored/ignored.go 0000664 0000000 0000000 00000001752 14143223131 0023011 0 ustar 00root root 0000000 0000000 package pkg
//lint:ignore U1000 consider yourself used
type t1 struct{} // used
type t2 struct{} // used
type t3 struct{} // used
func (t1) fn1() {} // used
func (t1) fn2() {} // used
func (t1) fn3() {} // used
//lint:ignore U1000 be gone
func (t2) fn1() {} // used
func (t2) fn2() {} // unused
func (t2) fn3() {} // unused
func (t3) fn1() {} // unused
func (t3) fn2() {} // unused
func (t3) fn3() {} // unused
//lint:ignore U1000 consider yourself used
func fn() { // used
var _ t2
var _ t3
}
//lint:ignore U1000 bye
type t4 struct { // used
x int // used
}
func (t4) bar() {} // used
//lint:ignore U1000 consider yourself used
type t5 map[int]struct { // used
y int // used
}
//lint:ignore U1000 consider yourself used
type t6 interface { // used
foo() // used
}
//lint:ignore U1000 consider yourself used
type t7 = struct { // used
z int // used
}
//lint:ignore U1000 consider yourself used
type t8 struct{} // used
func (t8) fn() { // used
otherFn()
}
func otherFn() {} // used
go-tools-2021.1.2/unused/testdata/src/ignored/ignored2.go 0000664 0000000 0000000 00000000050 14143223131 0023061 0 ustar 00root root 0000000 0000000 package pkg
func (t1) fn4() {} // used
go-tools-2021.1.2/unused/testdata/src/ignored/ignored3.go 0000664 0000000 0000000 00000000175 14143223131 0023072 0 ustar 00root root 0000000 0000000 //lint:file-ignore U1000 consider everything in here used
package pkg
type t9 struct{} // used
func (t9) fn1() {} // used
go-tools-2021.1.2/unused/testdata/src/ignored/ignored4.go 0000664 0000000 0000000 00000000050 14143223131 0023063 0 ustar 00root root 0000000 0000000 package pkg
func (t9) fn2() {} // used
go-tools-2021.1.2/unused/testdata/src/interfaces/ 0000775 0000000 0000000 00000000000 14143223131 0021522 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/interfaces/interfaces.go 0000664 0000000 0000000 00000001277 14143223131 0024203 0 ustar 00root root 0000000 0000000 package pkg
type I interface { // used
fn1() // used
}
type t struct{} // used
func (t) fn1() {} // used
func (t) fn2() {} // unused
func init() { // used
_ = t{}
}
type I1 interface { // used
Foo() // used
}
type I2 interface { // used
Foo() // used
bar() // used
}
type i3 interface { // unused
foo()
bar()
}
type t1 struct{} // used
type t2 struct{} // used
type t3 struct{} // used
type t4 struct { // used
t3 // used
}
func (t1) Foo() {} // used
func (t2) Foo() {} // used
func (t2) bar() {} // used
func (t3) Foo() {} // used
func (t3) bar() {} // used
func Fn() { // used
var v1 t1
var v2 t2
var v3 t3
var v4 t4
_ = v1
_ = v2
_ = v3
var x interface{} = v4
_ = x.(I2)
}
go-tools-2021.1.2/unused/testdata/src/interfaces2/ 0000775 0000000 0000000 00000000000 14143223131 0021604 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/interfaces2/interfaces.go 0000664 0000000 0000000 00000000246 14143223131 0024260 0 ustar 00root root 0000000 0000000 package pkg
type I interface { // used
foo() // used
}
type T struct{} // used
func (T) foo() {} // used
func (T) bar() {} // unused
var _ struct {
T // used
}
go-tools-2021.1.2/unused/testdata/src/linkname/ 0000775 0000000 0000000 00000000000 14143223131 0021175 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/linkname/linkname.go 0000664 0000000 0000000 00000000533 14143223131 0023323 0 ustar 00root root 0000000 0000000 package pkg
import _ "unsafe"
//other:directive
//go:linkname ol other4
//go:linkname foo other1
func foo() {} // used
//go:linkname bar other2
var bar int // used
var (
baz int // unused
//go:linkname qux other3
qux int // used
)
//go:linkname fisk other3
var (
fisk int // used
)
var ol int // used
//go:linkname doesnotexist other5
go-tools-2021.1.2/unused/testdata/src/main/ 0000775 0000000 0000000 00000000000 14143223131 0020323 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/main/main.go 0000664 0000000 0000000 00000000263 14143223131 0021577 0 ustar 00root root 0000000 0000000 package main
func Fn1() {} // used
func Fn2() {} // used
func fn3() {} // unused
const X = 1 // used
var Y = 2 // used
type Z struct{} // used
func main() { // used
Fn1()
}
go-tools-2021.1.2/unused/testdata/src/mapslice/ 0000775 0000000 0000000 00000000000 14143223131 0021174 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/mapslice/mapslice.go 0000664 0000000 0000000 00000000124 14143223131 0023315 0 ustar 00root root 0000000 0000000 package pkg
type M map[int]int // used
func Fn() { // used
var n M
_ = []M{n}
}
go-tools-2021.1.2/unused/testdata/src/methods/ 0000775 0000000 0000000 00000000000 14143223131 0021042 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/methods/methods.go 0000664 0000000 0000000 00000000347 14143223131 0023040 0 ustar 00root root 0000000 0000000 package pkg
type t1 struct{} // used
type t2 struct { // used
t3 // used
}
type t3 struct{} // used
func (t1) Foo() {} // used
func (t3) Foo() {} // used
func (t3) foo() {} // unused
func init() { // used
_ = t1{}
_ = t2{}
}
go-tools-2021.1.2/unused/testdata/src/named/ 0000775 0000000 0000000 00000000000 14143223131 0020463 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/named/named.go 0000664 0000000 0000000 00000000077 14143223131 0022102 0 ustar 00root root 0000000 0000000 package pkg
type t1 struct{} // used
type T2 t1 // used
go-tools-2021.1.2/unused/testdata/src/nested/ 0000775 0000000 0000000 00000000000 14143223131 0020661 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/nested/nested.go 0000664 0000000 0000000 00000000673 14143223131 0022500 0 ustar 00root root 0000000 0000000 package pkg
type t1 struct{} // unused
func (t1) fragment() {} // unused
func fn1() bool { // unused
var v interface{} = t1{}
switch obj := v.(type) {
case interface {
fragment()
}:
obj.fragment()
}
return false
}
type t2 struct{} // used
func (t2) fragment() {} // used
func Fn() bool { // used
var v interface{} = t2{}
switch obj := v.(type) {
case interface {
fragment() // used
}:
obj.fragment()
}
return false
}
go-tools-2021.1.2/unused/testdata/src/nocopy-main/ 0000775 0000000 0000000 00000000000 14143223131 0021630 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/nocopy-main/nocopy-main.go 0000664 0000000 0000000 00000001075 14143223131 0024413 0 ustar 00root root 0000000 0000000 package main
type myNoCopy1 struct{} // used
type myNoCopy2 struct{} // used
type locker struct{} // unused
type someStruct struct { // unused
x int
}
func (myNoCopy1) Lock() {} // used
func (recv myNoCopy2) Lock() {} // used
func (locker) Lock() {} // unused
func (locker) Unlock() {} // unused
func (someStruct) Lock() {} // unused
type T struct { // used
noCopy1 myNoCopy1 // used
noCopy2 myNoCopy2 // used
field1 someStruct // unused
field2 locker // unused
field3 int // unused
}
func main() { // used
_ = T{}
}
go-tools-2021.1.2/unused/testdata/src/nocopy/ 0000775 0000000 0000000 00000000000 14143223131 0020706 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/nocopy/nocopy.go 0000664 0000000 0000000 00000001032 14143223131 0022540 0 ustar 00root root 0000000 0000000 package bar
type myNoCopy1 struct{} // used
type myNoCopy2 struct{} // used
type locker struct{} // unused
type someStruct struct { // unused
x int
}
func (myNoCopy1) Lock() {} // used
func (recv myNoCopy2) Lock() {} // used
func (locker) Lock() {} // unused
func (locker) Unlock() {} // unused
func (someStruct) Lock() {} // unused
type T struct { // used
noCopy1 myNoCopy1 // used
noCopy2 myNoCopy2 // used
field1 someStruct // unused
field2 locker // unused
field3 int // unused
}
go-tools-2021.1.2/unused/testdata/src/pointer-type-embedding/ 0000775 0000000 0000000 00000000000 14143223131 0023752 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/pointer-type-embedding/pointer-type-embedding.go 0000664 0000000 0000000 00000000257 14143223131 0030660 0 ustar 00root root 0000000 0000000 package pkg
func init() { // used
var p P
_ = p.n
}
type T0 struct { // used
m int // unused
n int // used
}
type T1 struct { // used
T0 // used
}
type P *T1 // used
go-tools-2021.1.2/unused/testdata/src/pointers/ 0000775 0000000 0000000 00000000000 14143223131 0021242 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/pointers/pointers.go 0000664 0000000 0000000 00000000312 14143223131 0023430 0 ustar 00root root 0000000 0000000 package baz
import "fmt"
type Foo interface { // used
bar() // used
}
func Bar(f Foo) { // used
f.bar()
}
type Buzz struct{} // used
func (b *Buzz) bar() { // used
fmt.Println("foo bar buzz")
}
go-tools-2021.1.2/unused/testdata/src/quiet/ 0000775 0000000 0000000 00000000000 14143223131 0020526 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/quiet/quiet.go 0000664 0000000 0000000 00000000743 14143223131 0022210 0 ustar 00root root 0000000 0000000 package pkg
type iface interface { // unused
foo()
}
type t1 struct{} // unused
func (t1) foo() {} // unused
type t2 struct{} // used
func (t t2) bar(arg int) (ret int) { return 0 } // unused
func init() { // used
_ = t2{}
}
type t3 struct { // unused
a int
b int
}
type T struct{} // used
func fn1() { // unused
meh := func(arg T) {
}
meh(T{})
}
type localityList []int // unused
func (l *localityList) Fn1() {} // unused
func (l *localityList) Fn2() {} // unused
go-tools-2021.1.2/unused/testdata/src/selectors/ 0000775 0000000 0000000 00000000000 14143223131 0021402 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/selectors/selectors.go 0000664 0000000 0000000 00000000211 14143223131 0023726 0 ustar 00root root 0000000 0000000 package pkg
type t struct { // used
f int // used
}
func fn(v *t) { // used
println(v.f)
}
func init() { // used
var v t
fn(&v)
}
go-tools-2021.1.2/unused/testdata/src/switch_interface/ 0000775 0000000 0000000 00000000000 14143223131 0022720 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/switch_interface/switch_interface.go 0000664 0000000 0000000 00000000401 14143223131 0026563 0 ustar 00root root 0000000 0000000 package pkg
type t struct{} // used
func (t) fragment() {} // used
func fn() bool { // used
var v interface{} = t{}
switch obj := v.(type) {
case interface {
fragment() // used
}:
obj.fragment()
}
return false
}
var x = fn() // used
var _ = x
go-tools-2021.1.2/unused/testdata/src/tests-main/ 0000775 0000000 0000000 00000000000 14143223131 0021463 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/tests-main/main.go 0000664 0000000 0000000 00000000015 14143223131 0022732 0 ustar 00root root 0000000 0000000 package main
go-tools-2021.1.2/unused/testdata/src/tests-main/main_test.go 0000664 0000000 0000000 00000000172 14143223131 0023775 0 ustar 00root root 0000000 0000000 package main
import (
"testing"
)
type t1 struct{} // used_test
func TestFoo(t *testing.T) { // used_test
_ = t1{}
}
go-tools-2021.1.2/unused/testdata/src/tests/ 0000775 0000000 0000000 00000000000 14143223131 0020541 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/tests/tests.go 0000664 0000000 0000000 00000000056 14143223131 0022233 0 ustar 00root root 0000000 0000000 package pkg
func fn() {} // unused used_test
go-tools-2021.1.2/unused/testdata/src/tests/tests_test.go 0000664 0000000 0000000 00000000120 14143223131 0023262 0 ustar 00root root 0000000 0000000 package pkg
import "testing"
func TestFn(t *testing.T) { // used_test
fn()
}
go-tools-2021.1.2/unused/testdata/src/type-dedup/ 0000775 0000000 0000000 00000000000 14143223131 0021457 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/type-dedup/dedup.go 0000664 0000000 0000000 00000000315 14143223131 0023106 0 ustar 00root root 0000000 0000000 package pkg
type t1 struct { // used
a int // used
b int // unused
}
type t2 struct { // used
a int // unused
b int // used
}
func Fn() { // used
x := t1{}
y := t2{}
println(x.a)
println(y.b)
}
go-tools-2021.1.2/unused/testdata/src/type-dedup2/ 0000775 0000000 0000000 00000000000 14143223131 0021541 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/type-dedup2/dedup.go 0000664 0000000 0000000 00000000377 14143223131 0023200 0 ustar 00root root 0000000 0000000 package pkg
func fn1(t struct { // used
a int // used
b int // used
}) {
println(t.a)
fn2(t)
}
func fn2(t struct { // used
a int // used
b int // used
}) {
println(t.b)
}
func Fn() { // used
fn1(struct {
a int // used
b int // used
}{})
}
go-tools-2021.1.2/unused/testdata/src/type-dedup3/ 0000775 0000000 0000000 00000000000 14143223131 0021542 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/type-dedup3/dedup.go 0000664 0000000 0000000 00000000403 14143223131 0023167 0 ustar 00root root 0000000 0000000 package pkg
func fn1(t struct { // used
a int // used
b int // used
}) {
fn2(t)
}
func fn2(t struct { // used
a int // used
b int // used
}) {
println(t.a)
println(t.b)
}
func Fn() { // used
fn1(struct {
a int // used
b int // used
}{1, 2})
}
go-tools-2021.1.2/unused/testdata/src/types/ 0000775 0000000 0000000 00000000000 14143223131 0020543 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/types/types.go 0000664 0000000 0000000 00000000342 14143223131 0022235 0 ustar 00root root 0000000 0000000 package pkg
import "reflect"
type wkt interface { // used
XXX_WellKnownType() string // used
}
var typeOfWkt = reflect.TypeOf((*wkt)(nil)).Elem() // used
func Fn() { // used
_ = typeOfWkt
}
type t *int // used
var _ t
go-tools-2021.1.2/unused/testdata/src/unused-argument/ 0000775 0000000 0000000 00000000000 14143223131 0022522 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/unused-argument/unused-argument.go 0000664 0000000 0000000 00000000213 14143223131 0026170 0 ustar 00root root 0000000 0000000 package main
type t1 struct{} // used
type t2 struct{} // used
func (t1) foo(arg *t2) {} // used
func init() { // used
t1{}.foo(nil)
}
go-tools-2021.1.2/unused/testdata/src/unused_type/ 0000775 0000000 0000000 00000000000 14143223131 0021743 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/unused_type/unused_type.go 0000664 0000000 0000000 00000000331 14143223131 0024633 0 ustar 00root root 0000000 0000000 package pkg
type t1 struct{} // unused
func (t1) Fn() {} // unused
type t2 struct{} // used
func (*t2) Fn() {} // used
func init() { // used
(*t2).Fn(nil)
}
type t3 struct{} // unused
func (t3) fn() // unused
go-tools-2021.1.2/unused/testdata/src/variables/ 0000775 0000000 0000000 00000000000 14143223131 0021347 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/testdata/src/variables/variables.go 0000664 0000000 0000000 00000000662 14143223131 0023652 0 ustar 00root root 0000000 0000000 package pkg
var a byte // used
var b [16]byte // used
type t1 struct{} // used
type t2 struct{} // used
type t3 struct{} // used
type t4 struct{} // used
type t5 struct{} // used
type iface interface{} // used
var x t1 // used
var y = t2{} // used
var j = t3{} // used
var k = t4{} // used
var l iface = t5{} // used
func Fn() { // used
println(a)
_ = b[:]
_ = x
_ = y
_ = j
_ = k
_ = l
}
go-tools-2021.1.2/unused/testdata/src/variables/vartype.go 0000664 0000000 0000000 00000000301 14143223131 0023362 0 ustar 00root root 0000000 0000000 package pkg
type t181025 struct{} // used
func (t181025) F() {} // used
// package-level variable after function declaration used to trigger a
// bug in unused.
var V181025 t181025 // used
go-tools-2021.1.2/unused/typemap/ 0000775 0000000 0000000 00000000000 14143223131 0016456 5 ustar 00root root 0000000 0000000 go-tools-2021.1.2/unused/typemap/identical.go 0000664 0000000 0000000 00000011330 14143223131 0020737 0 ustar 00root root 0000000 0000000 package typemap
import (
"go/types"
)
// Unlike types.Identical, receivers of Signature types are not ignored.
// Unlike types.Identical, interfaces are compared via pointer equality (except for the empty interface, which gets deduplicated).
// Unlike types.Identical, structs are compared via pointer equality.
func identical0(x, y types.Type) bool {
if x == y {
return true
}
switch x := x.(type) {
case *types.Basic:
// Basic types are singletons except for the rune and byte
// aliases, thus we cannot solely rely on the x == y check
// above. See also comment in TypeName.IsAlias.
if y, ok := y.(*types.Basic); ok {
return x.Kind() == y.Kind()
}
case *types.Array:
// Two array types are identical if they have identical element types
// and the same array length.
if y, ok := y.(*types.Array); ok {
// If one or both array lengths are unknown (< 0) due to some error,
// assume they are the same to avoid spurious follow-on errors.
return (x.Len() < 0 || y.Len() < 0 || x.Len() == y.Len()) && identical0(x.Elem(), y.Elem())
}
case *types.Slice:
// Two slice types are identical if they have identical element types.
if y, ok := y.(*types.Slice); ok {
return identical0(x.Elem(), y.Elem())
}
case *types.Struct:
if y, ok := y.(*types.Struct); ok {
return x == y
}
case *types.Pointer:
// Two pointer types are identical if they have identical base types.
if y, ok := y.(*types.Pointer); ok {
return identical0(x.Elem(), y.Elem())
}
case *types.Tuple:
// Two tuples types are identical if they have the same number of elements
// and corresponding elements have identical types.
if y, ok := y.(*types.Tuple); ok {
if x.Len() == y.Len() {
if x != nil {
for i := 0; i < x.Len(); i++ {
v := x.At(i)
w := y.At(i)
if !identical0(v.Type(), w.Type()) {
return false
}
}
}
return true
}
}
case *types.Signature:
// Two function types are identical if they have the same number of parameters
// and result values, corresponding parameter and result types are identical,
// and either both functions are variadic or neither is. Parameter and result
// names are not required to match.
if y, ok := y.(*types.Signature); ok {
return x.Variadic() == y.Variadic() &&
identical0(x.Params(), y.Params()) &&
identical0(x.Results(), y.Results()) &&
(x.Recv() != nil && y.Recv() != nil && identical0(x.Recv().Type(), y.Recv().Type()) || x.Recv() == nil && y.Recv() == nil)
}
case *types.Interface:
// The issue with interfaces, typeutil.Map and types.Identical
//
// types.Identical, when comparing two interfaces, only looks at the set
// of all methods, not differentiating between implicit (embedded) and
// explicit methods.
//
// When we see the following two types, in source order
//
// type I1 interface { foo() }
// type I2 interface { I1 }
//
// then we will first correctly process I1 and its underlying type. When
// we get to I2, we will see that its underlying type is identical to
// that of I1 and not process it again. This, however, means that we will
// not record the fact that I2 embeds I1. If only I2 is reachable via the
// graph root, then I1 will not be considered used.
//
// We choose to be lazy and compare interfaces by their
// pointers. This will obviously miss identical interfaces,
// but this only has a runtime cost, it doesn't affect
// correctness.
if y, ok := y.(*types.Interface); ok {
if x.NumEmbeddeds() == 0 &&
y.NumEmbeddeds() == 0 &&
x.NumMethods() == 0 &&
y.NumMethods() == 0 {
// all truly empty interfaces are the same
return true
}
return x == y
}
case *types.Map:
// Two map types are identical if they have identical key and value types.
if y, ok := y.(*types.Map); ok {
return identical0(x.Key(), y.Key()) && identical0(x.Elem(), y.Elem())
}
case *types.Chan:
// Two channel types are identical if they have identical value types
// and the same direction.
if y, ok := y.(*types.Chan); ok {
return x.Dir() == y.Dir() && identical0(x.Elem(), y.Elem())
}
case *types.Named:
// Two named types are identical if their type names originate
// in the same type declaration.
if y, ok := y.(*types.Named); ok {
return x.Obj() == y.Obj()
}
case nil:
default:
panic("unreachable")
}
return false
}
// Identical reports whether x and y are identical types.
// Unlike types.Identical, receivers of Signature types are not ignored.
// Unlike types.Identical, interfaces are compared via pointer equality (except for the empty interface, which gets deduplicated).
// Unlike types.Identical, structs are compared via pointer equality.
func Identical(x, y types.Type) (ret bool) {
return identical0(x, y)
}
go-tools-2021.1.2/unused/typemap/map.go 0000664 0000000 0000000 00000020001 14143223131 0017553 0 ustar 00root root 0000000 0000000 // Copyright 2014 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 typemap defines Map, a mapping from types.Type to interface{} values.
package typemap
import (
"bytes"
"fmt"
"go/types"
"reflect"
)
// Map is a hash-table-based mapping from types (types.Type) to
// arbitrary interface{} values. The concrete types that implement
// the Type interface are pointers. Since they are not canonicalized,
// == cannot be used to check for equivalence, and thus we cannot
// simply use a Go map.
//
// Just as with map[K]V, a nil *Map is a valid empty map.
//
// Not thread-safe.
//
// This fork handles Signatures correctly, respecting method
// receivers. Furthermore, it doesn't deduplicate interfaces or
// structs. Interfaces aren't deduplicated as not to conflate implicit
// and explicit methods. Structs aren't deduplicated because we track
// fields of each type separately.
//
type Map struct {
hasher Hasher // shared by many Maps
table map[uint32][]entry // maps hash to bucket; entry.key==nil means unused
length int // number of map entries
}
// entry is an entry (key/value association) in a hash bucket.
type entry struct {
key types.Type
value interface{}
}
// SetHasher sets the hasher used by Map.
//
// All Hashers are functionally equivalent but contain internal state
// used to cache the results of hashing previously seen types.
//
// A single Hasher created by MakeHasher() may be shared among many
// Maps. This is recommended if the instances have many keys in
// common, as it will amortize the cost of hash computation.
//
// A Hasher may grow without bound as new types are seen. Even when a
// type is deleted from the map, the Hasher never shrinks, since other
// types in the map may reference the deleted type indirectly.
//
// Hashers are not thread-safe, and read-only operations such as
// Map.Lookup require updates to the hasher, so a full Mutex lock (not a
// read-lock) is require around all Map operations if a shared
// hasher is accessed from multiple threads.
//
// If SetHasher is not called, the Map will create a private hasher at
// the first call to Insert.
//
func (m *Map) SetHasher(hasher Hasher) {
m.hasher = hasher
}
// Delete removes the entry with the given key, if any.
// It returns true if the entry was found.
//
func (m *Map) Delete(key types.Type) bool {
if m != nil && m.table != nil {
hash := m.hasher.Hash(key)
bucket := m.table[hash]
for i, e := range bucket {
if e.key != nil && Identical(key, e.key) {
// We can't compact the bucket as it
// would disturb iterators.
bucket[i] = entry{}
m.length--
return true
}
}
}
return false
}
// At returns the map entry for the given key.
// The result is nil if the entry is not present.
//
func (m *Map) At(key types.Type) interface{} {
if m != nil && m.table != nil {
for _, e := range m.table[m.hasher.Hash(key)] {
if e.key != nil && Identical(key, e.key) {
return e.value
}
}
}
return nil
}
// Set sets the map entry for key to val,
// and returns the previous entry, if any.
func (m *Map) Set(key types.Type, value interface{}) (prev interface{}) {
if m.table != nil {
hash := m.hasher.Hash(key)
bucket := m.table[hash]
var hole *entry
for i, e := range bucket {
if e.key == nil {
hole = &bucket[i]
} else if Identical(key, e.key) {
prev = e.value
bucket[i].value = value
return
}
}
if hole != nil {
*hole = entry{key, value} // overwrite deleted entry
} else {
m.table[hash] = append(bucket, entry{key, value})
}
} else {
if m.hasher.memo == nil {
m.hasher = MakeHasher()
}
hash := m.hasher.Hash(key)
m.table = map[uint32][]entry{hash: {entry{key, value}}}
}
m.length++
return
}
// Len returns the number of map entries.
func (m *Map) Len() int {
if m != nil {
return m.length
}
return 0
}
// Iterate calls function f on each entry in the map in unspecified order.
//
// If f should mutate the map, Iterate provides the same guarantees as
// Go maps: if f deletes a map entry that Iterate has not yet reached,
// f will not be invoked for it, but if f inserts a map entry that
// Iterate has not yet reached, whether or not f will be invoked for
// it is unspecified.
//
func (m *Map) Iterate(f func(key types.Type, value interface{})) {
if m != nil {
for _, bucket := range m.table {
for _, e := range bucket {
if e.key != nil {
f(e.key, e.value)
}
}
}
}
}
// Keys returns a new slice containing the set of map keys.
// The order is unspecified.
func (m *Map) Keys() []types.Type {
keys := make([]types.Type, 0, m.Len())
m.Iterate(func(key types.Type, _ interface{}) {
keys = append(keys, key)
})
return keys
}
func (m *Map) toString(values bool) string {
if m == nil {
return "{}"
}
var buf bytes.Buffer
fmt.Fprint(&buf, "{")
sep := ""
m.Iterate(func(key types.Type, value interface{}) {
fmt.Fprint(&buf, sep)
sep = ", "
fmt.Fprint(&buf, key)
if values {
fmt.Fprintf(&buf, ": %q", value)
}
})
fmt.Fprint(&buf, "}")
return buf.String()
}
// String returns a string representation of the map's entries.
// Values are printed using fmt.Sprintf("%v", v).
// Order is unspecified.
//
func (m *Map) String() string {
return m.toString(true)
}
// KeysString returns a string representation of the map's key set.
// Order is unspecified.
//
func (m *Map) KeysString() string {
return m.toString(false)
}
////////////////////////////////////////////////////////////////////////
// Hasher
// A Hasher maps each type to its hash value.
// For efficiency, a hasher uses memoization; thus its memory
// footprint grows monotonically over time.
// Hashers are not thread-safe.
// Hashers have reference semantics.
// Call MakeHasher to create a Hasher.
type Hasher struct {
memo map[types.Type]uint32
}
// MakeHasher returns a new Hasher instance.
func MakeHasher() Hasher {
return Hasher{make(map[types.Type]uint32)}
}
// Hash computes a hash value for the given type t such that
// Identical(t, t') => Hash(t) == Hash(t').
func (h Hasher) Hash(t types.Type) uint32 {
hash, ok := h.memo[t]
if !ok {
hash = h.hashFor(t)
h.memo[t] = hash
}
return hash
}
// hashString computes the FowlerβNollβVo hash of s.
func hashString(s string) uint32 {
var h uint32
for i := 0; i < len(s); i++ {
h ^= uint32(s[i])
h *= 16777619
}
return h
}
// hashFor computes the hash of t.
func (h Hasher) hashFor(t types.Type) uint32 {
// See Identical for rationale.
switch t := t.(type) {
case *types.Basic:
return uint32(t.Kind())
case *types.Array:
return 9043 + 2*uint32(t.Len()) + 3*h.Hash(t.Elem())
case *types.Slice:
return 9049 + 2*h.Hash(t.Elem())
case *types.Struct:
var hash uint32 = 9059
for i, n := 0, t.NumFields(); i < n; i++ {
f := t.Field(i)
if f.Anonymous() {
hash += 8861
}
hash += hashString(t.Tag(i))
hash += hashString(f.Name()) // (ignore f.Pkg)
hash += h.Hash(f.Type())
}
return hash
case *types.Pointer:
return 9067 + 2*h.Hash(t.Elem())
case *types.Signature:
var hash uint32 = 9091
if t.Variadic() {
hash *= 8863
}
return hash + 3*h.hashTuple(t.Params()) + 5*h.hashTuple(t.Results())
case *types.Interface:
var hash uint32 = 9103
for i, n := 0, t.NumMethods(); i < n; i++ {
// See go/types.identicalMethods for rationale.
// Method order is not significant.
// Ignore m.Pkg().
m := t.Method(i)
hash += 3*hashString(m.Name()) + 5*h.Hash(m.Type())
}
return hash
case *types.Map:
return 9109 + 2*h.Hash(t.Key()) + 3*h.Hash(t.Elem())
case *types.Chan:
return 9127 + 2*uint32(t.Dir()) + 3*h.Hash(t.Elem())
case *types.Named:
// Not safe with a copying GC; objects may move.
return uint32(reflect.ValueOf(t.Obj()).Pointer())
case *types.Tuple:
return h.hashTuple(t)
}
panic(t)
}
func (h Hasher) hashTuple(tuple *types.Tuple) uint32 {
// See go/types.identicalTypes for rationale.
n := tuple.Len()
var hash uint32 = 9137 + 2*uint32(n)
for i := 0; i < n; i++ {
hash += 3 * h.Hash(tuple.At(i).Type())
}
return hash
}
go-tools-2021.1.2/unused/typemap/map_test.go 0000664 0000000 0000000 00000011254 14143223131 0020624 0 ustar 00root root 0000000 0000000 // Copyright 2014 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 typemap_test
// TODO(adonovan):
// - test use of explicit hasher across two maps.
// - test hashcodes are consistent with equals for a range of types
// (e.g. all types generated by type-checking some body of real code).
import (
"go/types"
"testing"
"honnef.co/go/tools/unused/typemap"
)
var (
tStr = types.Typ[types.String] // string
tPStr1 = types.NewPointer(tStr) // *string
tPStr2 = types.NewPointer(tStr) // *string, again
tInt = types.Typ[types.Int] // int
tChanInt1 = types.NewChan(types.RecvOnly, tInt) // <-chan int
tChanInt2 = types.NewChan(types.RecvOnly, tInt) // <-chan int, again
)
func checkEqualButNotIdentical(t *testing.T, x, y types.Type, comment string) {
if !types.Identical(x, y) {
t.Errorf("%s: not equal: %s, %s", comment, x, y)
}
if x == y {
t.Errorf("%s: identical: %v, %v", comment, x, y)
}
}
func TestAxioms(t *testing.T) {
checkEqualButNotIdentical(t, tPStr1, tPStr2, "tPstr{1,2}")
checkEqualButNotIdentical(t, tChanInt1, tChanInt2, "tChanInt{1,2}")
}
func TestMap(t *testing.T) {
var tmap *typemap.Map
// All methods but Set are safe on on (*T)(nil).
_ = tmap.Len()
_ = tmap.At(tPStr1)
_ = tmap.Delete(tPStr1)
_ = tmap.KeysString()
_ = tmap.String()
tmap = new(typemap.Map)
// Length of empty map.
if l := tmap.Len(); l != 0 {
t.Errorf("Len() on empty Map: got %d, want 0", l)
}
// At of missing key.
if v := tmap.At(tPStr1); v != nil {
t.Errorf("At() on empty Map: got %v, want nil", v)
}
// Deletion of missing key.
if tmap.Delete(tPStr1) {
t.Errorf("Delete() on empty Map: got true, want false")
}
// Set of new key.
if prev := tmap.Set(tPStr1, "*string"); prev != nil {
t.Errorf("Set() on empty Map returned non-nil previous value %s", prev)
}
// Now: {*string: "*string"}
// Length of non-empty map.
if l := tmap.Len(); l != 1 {
t.Errorf("Len(): got %d, want 1", l)
}
// At via insertion key.
if v := tmap.At(tPStr1); v != "*string" {
t.Errorf("At(): got %q, want \"*string\"", v)
}
// At via equal key.
if v := tmap.At(tPStr2); v != "*string" {
t.Errorf("At(): got %q, want \"*string\"", v)
}
// Iteration over sole entry.
tmap.Iterate(func(key types.Type, value interface{}) {
if key != tPStr1 {
t.Errorf("Iterate: key: got %s, want %s", key, tPStr1)
}
if want := "*string"; value != want {
t.Errorf("Iterate: value: got %s, want %s", value, want)
}
})
// Section with key equal to present one.
if prev := tmap.Set(tPStr2, "*string again"); prev != "*string" {
t.Errorf("Set() previous value: got %s, want \"*string\"", prev)
}
// Section of another association.
if prev := tmap.Set(tChanInt1, "<-chan int"); prev != nil {
t.Errorf("Set() previous value: got %s, want nil", prev)
}
// Now: {*string: "*string again", <-chan int: "<-chan int"}
want1 := "{*string: \"*string again\", <-chan int: \"<-chan int\"}"
want2 := "{<-chan int: \"<-chan int\", *string: \"*string again\"}"
if s := tmap.String(); s != want1 && s != want2 {
t.Errorf("String(): got %s, want %s", s, want1)
}
want1 = "{*string, <-chan int}"
want2 = "{<-chan int, *string}"
if s := tmap.KeysString(); s != want1 && s != want2 {
t.Errorf("KeysString(): got %s, want %s", s, want1)
}
// Keys().
I := types.Identical
switch k := tmap.Keys(); {
case I(k[0], tChanInt1) && I(k[1], tPStr1): // ok
case I(k[1], tChanInt1) && I(k[0], tPStr1): // ok
default:
t.Errorf("Keys(): got %v, want %s", k, want2)
}
if l := tmap.Len(); l != 2 {
t.Errorf("Len(): got %d, want 1", l)
}
// At via original key.
if v := tmap.At(tPStr1); v != "*string again" {
t.Errorf("At(): got %q, want \"*string again\"", v)
}
hamming := 1
tmap.Iterate(func(key types.Type, value interface{}) {
switch {
case I(key, tChanInt1):
hamming *= 2 // ok
case I(key, tPStr1):
hamming *= 3 // ok
}
})
if hamming != 6 {
t.Errorf("Iterate: hamming: got %d, want %d", hamming, 6)
}
if v := tmap.At(tChanInt2); v != "<-chan int" {
t.Errorf("At(): got %q, want \"<-chan int\"", v)
}
// Deletion with key equal to present one.
if !tmap.Delete(tChanInt2) {
t.Errorf("Delete() of existing key: got false, want true")
}
// Now: {*string: "*string again"}
if l := tmap.Len(); l != 1 {
t.Errorf("Len(): got %d, want 1", l)
}
// Deletion again.
if !tmap.Delete(tPStr2) {
t.Errorf("Delete() of existing key: got false, want true")
}
// Now: {}
if l := tmap.Len(); l != 0 {
t.Errorf("Len(): got %d, want %d", l, 0)
}
if s := tmap.String(); s != "{}" {
t.Errorf("Len(): got %q, want %q", s, "")
}
}
go-tools-2021.1.2/unused/unused.go 0000664 0000000 0000000 00000136662 14143223131 0016647 0 ustar 00root root 0000000 0000000 package unused
import (
"fmt"
"go/ast"
"go/token"
"go/types"
"io"
"reflect"
"strings"
"honnef.co/go/tools/analysis/code"
"honnef.co/go/tools/analysis/facts"
"honnef.co/go/tools/analysis/lint"
"honnef.co/go/tools/analysis/report"
"honnef.co/go/tools/go/ast/astutil"
"honnef.co/go/tools/go/ir"
"honnef.co/go/tools/go/types/typeutil"
"honnef.co/go/tools/internal/passes/buildir"
"honnef.co/go/tools/unused/typemap"
"golang.org/x/tools/go/analysis"
)
var Debug io.Writer
// The graph we construct omits nodes along a path that do not
// contribute any new information to the solution. For example, the
// full graph for a function with a receiver would be Func ->
// Signature -> Var -> Type. However, since signatures cannot be
// unused, and receivers are always considered used, we can compact
// the graph down to Func -> Type. This makes the graph smaller, but
// harder to debug.
// TODO(dh): conversions between structs mark fields as used, but the
// conversion itself isn't part of that subgraph. even if the function
// containing the conversion is unused, the fields will be marked as
// used.
// TODO(dh): we cannot observe function calls in assembly files.
/*
- packages use:
- (1.1) exported named types
- (1.2) exported functions
- (1.3) exported variables
- (1.4) exported constants
- (1.5) init functions
- (1.6) functions exported to cgo
- (1.7) the main function iff in the main package
- (1.8) symbols linked via go:linkname
- named types use:
- (2.1) exported methods
- (2.2) the type they're based on
- (2.3) all their aliases. we can't easily track uses of aliases
because go/types turns them into uses of the aliased types. assume
that if a type is used, so are all of its aliases.
- (2.4) the pointer type. this aids with eagerly implementing
interfaces. if a method that implements an interface is defined on
a pointer receiver, and the pointer type is never used, but the
named type is, then we still want to mark the method as used.
- variables and constants use:
- their types
- functions use:
- (4.1) all their arguments, return parameters and receivers
- (4.2) anonymous functions defined beneath them
- (4.3) closures and bound methods.
this implements a simplified model where a function is used merely by being referenced, even if it is never called.
that way we don't have to keep track of closures escaping functions.
- (4.4) functions they return. we assume that someone else will call the returned function
- (4.5) functions/interface methods they call
- types they instantiate or convert to
- (4.7) fields they access
- (4.8) types of all instructions
- (4.9) package-level variables they assign to iff in tests (sinks for benchmarks)
- conversions use:
- (5.1) when converting between two equivalent structs, the fields in
either struct use each other. the fields are relevant for the
conversion, but only if the fields are also accessed outside the
conversion.
- (5.2) when converting to or from unsafe.Pointer, mark all fields as used.
- structs use:
- (6.1) fields of type NoCopy sentinel
- (6.2) exported fields
- (6.3) embedded fields that help implement interfaces (either fully implements it, or contributes required methods) (recursively)
- (6.4) embedded fields that have exported methods (recursively)
- (6.5) embedded structs that have exported fields (recursively)
- (7.1) field accesses use fields
- (7.2) fields use their types
- (8.0) How we handle interfaces:
- (8.1) We do not technically care about interfaces that only consist of
exported methods. Exported methods on concrete types are always
marked as used.
- Any concrete type implements all known interfaces. Even if it isn't
assigned to any interfaces in our code, the user may receive a value
of the type and expect to pass it back to us through an interface.
Concrete types use their methods that implement interfaces. If the
type is used, it uses those methods. Otherwise, it doesn't. This
way, types aren't incorrectly marked reachable through the edge
from method to type.
- (8.3) All interface methods are marked as used, even if they never get
called. This is to accommodate sum types (unexported interface
method that must exist but never gets called.)
- (8.4) All embedded interfaces are marked as used. This is an
extension of 8.3, but we have to explicitly track embedded
interfaces because in a chain C->B->A, B wouldn't be marked as
used by 8.3 just because it contributes A's methods to C.
- Inherent uses:
- thunks and other generated wrappers call the real function
- (9.2) variables use their types
- (9.3) types use their underlying and element types
- (9.4) conversions use the type they convert to
- (9.5) instructions use their operands
- (9.6) instructions use their operands' types
- (9.7) variable _reads_ use variables, writes do not, except in tests
- (9.8) runtime functions that may be called from user code via the compiler
- const groups:
(10.1) if one constant out of a block of constants is used, mark all
of them used. a lot of the time, unused constants exist for the sake
of completeness. See also
https://github.com/dominikh/go-tools/issues/365
- (11.1) anonymous struct types use all their fields. we cannot
deduplicate struct types, as that leads to order-dependent
reports. we can't not deduplicate struct types while still
tracking fields, because then each instance of the unnamed type in
the data flow chain will get its own fields, causing false
positives. Thus, we only accurately track fields of named struct
types, and assume that unnamed struct types use all their fields.
*/
func assert(b bool) {
if !b {
panic("failed assertion")
}
}
// /usr/lib/go/src/runtime/proc.go:433:6: func badmorestackg0 is unused (U1000)
// Functions defined in the Go runtime that may be called through
// compiler magic or via assembly.
var runtimeFuncs = map[string]bool{
// The first part of the list is copied from
// cmd/compile/internal/gc/builtin.go, var runtimeDecls
"newobject": true,
"panicindex": true,
"panicslice": true,
"panicdivide": true,
"panicmakeslicelen": true,
"throwinit": true,
"panicwrap": true,
"gopanic": true,
"gorecover": true,
"goschedguarded": true,
"printbool": true,
"printfloat": true,
"printint": true,
"printhex": true,
"printuint": true,
"printcomplex": true,
"printstring": true,
"printpointer": true,
"printiface": true,
"printeface": true,
"printslice": true,
"printnl": true,
"printsp": true,
"printlock": true,
"printunlock": true,
"concatstring2": true,
"concatstring3": true,
"concatstring4": true,
"concatstring5": true,
"concatstrings": true,
"cmpstring": true,
"intstring": true,
"slicebytetostring": true,
"slicebytetostringtmp": true,
"slicerunetostring": true,
"stringtoslicebyte": true,
"stringtoslicerune": true,
"slicecopy": true,
"slicestringcopy": true,
"decoderune": true,
"countrunes": true,
"convI2I": true,
"convT16": true,
"convT32": true,
"convT64": true,
"convTstring": true,
"convTslice": true,
"convT2E": true,
"convT2Enoptr": true,
"convT2I": true,
"convT2Inoptr": true,
"assertE2I": true,
"assertE2I2": true,
"assertI2I": true,
"assertI2I2": true,
"panicdottypeE": true,
"panicdottypeI": true,
"panicnildottype": true,
"ifaceeq": true,
"efaceeq": true,
"fastrand": true,
"makemap64": true,
"makemap": true,
"makemap_small": true,
"mapaccess1": true,
"mapaccess1_fast32": true,
"mapaccess1_fast64": true,
"mapaccess1_faststr": true,
"mapaccess1_fat": true,
"mapaccess2": true,
"mapaccess2_fast32": true,
"mapaccess2_fast64": true,
"mapaccess2_faststr": true,
"mapaccess2_fat": true,
"mapassign": true,
"mapassign_fast32": true,
"mapassign_fast32ptr": true,
"mapassign_fast64": true,
"mapassign_fast64ptr": true,
"mapassign_faststr": true,
"mapiterinit": true,
"mapdelete": true,
"mapdelete_fast32": true,
"mapdelete_fast64": true,
"mapdelete_faststr": true,
"mapiternext": true,
"mapclear": true,
"makechan64": true,
"makechan": true,
"chanrecv1": true,
"chanrecv2": true,
"chansend1": true,
"closechan": true,
"writeBarrier": true,
"typedmemmove": true,
"typedmemclr": true,
"typedslicecopy": true,
"selectnbsend": true,
"selectnbrecv": true,
"selectnbrecv2": true,
"selectsetpc": true,
"selectgo": true,
"block": true,
"makeslice": true,
"makeslice64": true,
"growslice": true,
"memmove": true,
"memclrNoHeapPointers": true,
"memclrHasPointers": true,
"memequal": true,
"memequal8": true,
"memequal16": true,
"memequal32": true,
"memequal64": true,
"memequal128": true,
"int64div": true,
"uint64div": true,
"int64mod": true,
"uint64mod": true,
"float64toint64": true,
"float64touint64": true,
"float64touint32": true,
"int64tofloat64": true,
"uint64tofloat64": true,
"uint32tofloat64": true,
"complex128div": true,
"racefuncenter": true,
"racefuncenterfp": true,
"racefuncexit": true,
"raceread": true,
"racewrite": true,
"racereadrange": true,
"racewriterange": true,
"msanread": true,
"msanwrite": true,
"x86HasPOPCNT": true,
"x86HasSSE41": true,
"arm64HasATOMICS": true,
// The second part of the list is extracted from assembly code in
// the standard library, with the exception of the runtime package itself
"abort": true,
"aeshashbody": true,
"args": true,
"asminit": true,
"badctxt": true,
"badmcall2": true,
"badmcall": true,
"badmorestackg0": true,
"badmorestackgsignal": true,
"badsignal2": true,
"callbackasm1": true,
"callCfunction": true,
"cgocallback_gofunc": true,
"cgocallbackg": true,
"checkgoarm": true,
"check": true,
"debugCallCheck": true,
"debugCallWrap": true,
"emptyfunc": true,
"entersyscall": true,
"exit": true,
"exits": true,
"exitsyscall": true,
"externalthreadhandler": true,
"findnull": true,
"goexit1": true,
"gostring": true,
"i386_set_ldt": true,
"_initcgo": true,
"init_thread_tls": true,
"ldt0setup": true,
"libpreinit": true,
"load_g": true,
"morestack": true,
"mstart": true,
"nacl_sysinfo": true,
"nanotimeQPC": true,
"nanotime": true,
"newosproc0": true,
"newproc": true,
"newstack": true,
"noted": true,
"nowQPC": true,
"osinit": true,
"printf": true,
"racecallback": true,
"reflectcallmove": true,
"reginit": true,
"rt0_go": true,
"save_g": true,
"schedinit": true,
"setldt": true,
"settls": true,
"sighandler": true,
"sigprofNonGo": true,
"sigtrampgo": true,
"_sigtramp": true,
"sigtramp": true,
"stackcheck": true,
"syscall_chdir": true,
"syscall_chroot": true,
"syscall_close": true,
"syscall_dup2": true,
"syscall_execve": true,
"syscall_exit": true,
"syscall_fcntl": true,
"syscall_forkx": true,
"syscall_gethostname": true,
"syscall_getpid": true,
"syscall_ioctl": true,
"syscall_pipe": true,
"syscall_rawsyscall6": true,
"syscall_rawSyscall6": true,
"syscall_rawsyscall": true,
"syscall_RawSyscall": true,
"syscall_rawsysvicall6": true,
"syscall_setgid": true,
"syscall_setgroups": true,
"syscall_setpgid": true,
"syscall_setsid": true,
"syscall_setuid": true,
"syscall_syscall6": true,
"syscall_syscall": true,
"syscall_Syscall": true,
"syscall_sysvicall6": true,
"syscall_wait4": true,
"syscall_write": true,
"traceback": true,
"tstart": true,
"usplitR0": true,
"wbBufFlush": true,
"write": true,
}
type pkg struct {
Fset *token.FileSet
Files []*ast.File
Pkg *types.Package
TypesInfo *types.Info
TypesSizes types.Sizes
IR *ir.Package
SrcFuncs []*ir.Function
Directives []lint.Directive
}
// TODO(dh): should we return a map instead of two slices?
type Result struct {
Used []types.Object
Unused []types.Object
}
type SerializedResult struct {
Used []SerializedObject
Unused []SerializedObject
}
var Analyzer = &lint.Analyzer{
Doc: &lint.Documentation{
Title: "Unused code",
},
Analyzer: &analysis.Analyzer{
Name: "U1000",
Doc: "Unused code",
Run: run,
Requires: []*analysis.Analyzer{buildir.Analyzer, facts.Generated, facts.Directives},
ResultType: reflect.TypeOf(Result{}),
},
}
type SerializedObject struct {
Name string
Position token.Position
DisplayPosition token.Position
Kind string
InGenerated bool
}
func typString(obj types.Object) string {
switch obj := obj.(type) {
case *types.Func:
return "func"
case *types.Var:
if obj.IsField() {
return "field"
}
return "var"
case *types.Const:
return "const"
case *types.TypeName:
return "type"
default:
return "identifier"
}
}
func Serialize(pass *analysis.Pass, res Result, fset *token.FileSet) SerializedResult {
// OPT(dh): there's no point in serializing Used objects that are
// always used, such as exported names, blank identifiers, or
// anonymous struct fields. Used only exists to overrule Unused of
// a different package. If something can never be unused, then its
// presence in Used is useless.
//
// I'm not sure if this should happen when serializing, or when
// returning Result.
out := SerializedResult{
Used: make([]SerializedObject, len(res.Used)),
Unused: make([]SerializedObject, len(res.Unused)),
}
for i, obj := range res.Used {
out.Used[i] = serializeObject(pass, fset, obj)
}
for i, obj := range res.Unused {
out.Unused[i] = serializeObject(pass, fset, obj)
}
return out
}
func serializeObject(pass *analysis.Pass, fset *token.FileSet, obj types.Object) SerializedObject {
name := obj.Name()
if sig, ok := obj.Type().(*types.Signature); ok && sig.Recv() != nil {
switch sig.Recv().Type().(type) {
case *types.Named, *types.Pointer:
typ := types.TypeString(sig.Recv().Type(), func(*types.Package) string { return "" })
if len(typ) > 0 && typ[0] == '*' {
name = fmt.Sprintf("(%s).%s", typ, obj.Name())
} else if len(typ) > 0 {
name = fmt.Sprintf("%s.%s", typ, obj.Name())
}
}
}
return SerializedObject{
Name: name,
Position: fset.PositionFor(obj.Pos(), false),
DisplayPosition: report.DisplayPosition(fset, obj.Pos()),
Kind: typString(obj),
InGenerated: code.IsGenerated(pass, obj.Pos()),
}
}
func debugf(f string, v ...interface{}) {
if Debug != nil {
fmt.Fprintf(Debug, f, v...)
}
}
func run(pass *analysis.Pass) (interface{}, error) {
irpkg := pass.ResultOf[buildir.Analyzer].(*buildir.IR)
dirs := pass.ResultOf[facts.Directives].([]lint.Directive)
pkg := &pkg{
Fset: pass.Fset,
Files: pass.Files,
Pkg: pass.Pkg,
TypesInfo: pass.TypesInfo,
TypesSizes: pass.TypesSizes,
IR: irpkg.Pkg,
SrcFuncs: irpkg.SrcFuncs,
Directives: dirs,
}
g := newGraph()
g.entry(pkg)
used, unused := results(g)
if Debug != nil {
debugNode := func(n *node) {
if n.obj == nil {
debugf("n%d [label=\"Root\"];\n", n.id)
} else {
color := "red"
if n.seen {
color = "green"
}
debugf("n%d [label=%q, color=%q];\n", n.id, fmt.Sprintf("(%T) %s", n.obj, n.obj), color)
}
for _, e := range n.used {
for i := edgeKind(1); i < 64; i++ {
if e.kind.is(1 << i) {
debugf("n%d -> n%d [label=%q];\n", n.id, e.node.id, edgeKind(1< 1 {
cg := &constGroup{}
g.see(cg)
for _, spec := range specs {
for _, name := range spec.(*ast.ValueSpec).Names {
obj := pkg.TypesInfo.ObjectOf(name)
// (10.1) const groups
g.seeAndUse(obj, cg, edgeConstGroup)
g.use(cg, obj, edgeConstGroup)
}
}
}
}
case token.VAR:
for _, spec := range n.Specs {
v := spec.(*ast.ValueSpec)
for _, name := range v.Names {
T := pkg.TypesInfo.TypeOf(name)
if fn != nil {
g.seeAndUse(T, fn, edgeVarDecl)
} else {
// TODO(dh): we likely want to make
// the type used by the variable, not
// the package containing the
// variable. But then we have to take
// special care of blank identifiers.
g.seeAndUse(T, nil, edgeVarDecl)
}
g.typ(T, nil)
}
}
case token.TYPE:
for _, spec := range n.Specs {
// go/types doesn't provide a way to go from a
// types.Named to the named type it was based on
// (the t1 in type t2 t1). Therefore we walk the
// AST and process GenDecls.
//
// (2.2) named types use the type they're based on
v := spec.(*ast.TypeSpec)
T := pkg.TypesInfo.TypeOf(v.Type)
obj := pkg.TypesInfo.ObjectOf(v.Name)
g.see(obj)
g.see(T)
g.use(T, obj, edgeType)
g.typ(obj.Type(), nil)
g.typ(T, nil)
if v.Assign != 0 {
aliasFor := obj.(*types.TypeName).Type()
// (2.3) named types use all their aliases. we can't easily track uses of aliases
if isIrrelevant(aliasFor) {
// We do not track the type this is an
// alias for (for example builtins), so
// just mark the alias used.
//
// FIXME(dh): what about aliases declared inside functions?
g.use(obj, nil, edgeAlias)
} else {
g.see(aliasFor)
g.seeAndUse(obj, aliasFor, edgeAlias)
}
}
}
}
}
return true
})
}
for _, m := range pkg.IR.Members {
switch m := m.(type) {
case *ir.NamedConst:
// nothing to do, we collect all constants from Defs
case *ir.Global:
if m.Object() != nil {
g.see(m.Object())
if m.Object().Exported() {
// (1.3) packages use exported variables
g.use(m.Object(), nil, edgeExportedVariable)
}
}
case *ir.Function:
mObj := owningObject(m)
if mObj != nil {
g.see(mObj)
}
//lint:ignore SA9003 handled implicitly
if m.Name() == "init" {
// (1.5) packages use init functions
//
// This is handled implicitly. The generated init
// function has no object, thus everything in it will
// be owned by the package.
}
// This branch catches top-level functions, not methods.
if m.Object() != nil && m.Object().Exported() {
// (1.2) packages use exported functions
g.use(mObj, nil, edgeExportedFunction)
}
if m.Name() == "main" && pkg.Pkg.Name() == "main" {
// (1.7) packages use the main function iff in the main package
g.use(mObj, nil, edgeMainFunction)
}
if pkg.Pkg.Path() == "runtime" && runtimeFuncs[m.Name()] {
// (9.8) runtime functions that may be called from user code via the compiler
g.use(mObj, nil, edgeRuntimeFunction)
}
if m.Source() != nil {
doc := m.Source().(*ast.FuncDecl).Doc
if doc != nil {
for _, cmt := range doc.List {
if strings.HasPrefix(cmt.Text, "//go:cgo_export_") {
// (1.6) packages use functions exported to cgo
g.use(mObj, nil, edgeCgoExported)
}
}
}
}
g.function(m)
case *ir.Type:
g.see(m.Object())
if m.Object().Exported() {
// (1.1) packages use exported named types
g.use(m.Object(), nil, edgeExportedType)
}
g.typ(m.Type(), nil)
default:
panic(fmt.Sprintf("unreachable: %T", m))
}
}
// OPT(dh): can we find meaningful initial capacities for these slices?
var ifaces []*types.Interface
var notIfaces []types.Type
g.seenTypes.Iterate(func(t types.Type, _ interface{}) {
switch t := t.(type) {
case *types.Interface:
// OPT(dh): (8.1) we only need interfaces that have unexported methods
ifaces = append(ifaces, t)
default:
if _, ok := t.Underlying().(*types.Interface); !ok {
notIfaces = append(notIfaces, t)
}
}
})
// (8.0) handle interfaces
for _, t := range notIfaces {
ms := pkg.IR.Prog.MethodSets.MethodSet(t)
for _, iface := range ifaces {
if sels, ok := g.implements(t, iface, ms); ok {
for _, sel := range sels {
g.useMethod(t, sel, t, edgeImplements)
}
}
}
}
type ignoredKey struct {
file string
line int
}
ignores := map[ignoredKey]struct{}{}
for _, dir := range pkg.Directives {
if dir.Command != "ignore" && dir.Command != "file-ignore" {
continue
}
if len(dir.Arguments) == 0 {
continue
}
for _, check := range strings.Split(dir.Arguments[0], ",") {
if check == "U1000" {
pos := pkg.Fset.PositionFor(dir.Node.Pos(), false)
var key ignoredKey
switch dir.Command {
case "ignore":
key = ignoredKey{
pos.Filename,
pos.Line,
}
case "file-ignore":
key = ignoredKey{
pos.Filename,
-1,
}
}
ignores[key] = struct{}{}
break
}
}
}
if len(ignores) > 0 {
// all objects annotated with a //lint:ignore U1000 are considered used
for obj := range g.Nodes {
if obj, ok := obj.(types.Object); ok {
pos := pkg.Fset.PositionFor(obj.Pos(), false)
key1 := ignoredKey{
pos.Filename,
pos.Line,
}
key2 := ignoredKey{
pos.Filename,
-1,
}
_, ok := ignores[key1]
if !ok {
_, ok = ignores[key2]
}
if ok {
g.use(obj, nil, edgeIgnored)
// use methods and fields of ignored types
if obj, ok := obj.(*types.TypeName); ok {
if obj.IsAlias() {
if typ, ok := obj.Type().(*types.Named); ok && typ.Obj().Pkg() != obj.Pkg() {
// This is an alias of a named type in another package.
// Don't walk its fields or methods; we don't have to,
// and it breaks an assertion in graph.use because we're using an object that we haven't seen before.
//
// For aliases to types in the same package, we do want to ignore the fields and methods,
// because ignoring the alias should ignore the aliased type.
continue
}
}
if typ, ok := obj.Type().(*types.Named); ok {
for i := 0; i < typ.NumMethods(); i++ {
g.use(typ.Method(i), nil, edgeIgnored)
}
}
if typ, ok := obj.Type().Underlying().(*types.Struct); ok {
for i := 0; i < typ.NumFields(); i++ {
g.use(typ.Field(i), nil, edgeIgnored)
}
}
}
}
}
}
}
}
func (g *graph) useMethod(t types.Type, sel *types.Selection, by interface{}, kind edgeKind) {
obj := sel.Obj()
path := sel.Index()
assert(obj != nil)
if len(path) > 1 {
base := typeutil.Dereference(t).Underlying().(*types.Struct)
for _, idx := range path[:len(path)-1] {
next := base.Field(idx)
// (6.3) structs use embedded fields that help implement interfaces
g.see(base)
g.seeAndUse(next, base, edgeProvidesMethod)
base, _ = typeutil.Dereference(next.Type()).Underlying().(*types.Struct)
}
}
g.seeAndUse(obj, by, kind)
}
func owningObject(fn *ir.Function) types.Object {
if fn.Object() != nil {
return fn.Object()
}
if fn.Parent() != nil {
return owningObject(fn.Parent())
}
return nil
}
func (g *graph) function(fn *ir.Function) {
if fn.Package() != nil && fn.Package() != g.pkg.IR {
return
}
if _, ok := g.seenFns[fn]; ok {
return
}
g.seenFns[fn] = struct{}{}
// (4.1) functions use all their arguments, return parameters and receivers
g.signature(fn.Signature, owningObject(fn))
g.instructions(fn)
for _, anon := range fn.AnonFuncs {
// (4.2) functions use anonymous functions defined beneath them
//
// This fact is expressed implicitly. Anonymous functions have
// no types.Object, so their owner is the surrounding
// function.
g.function(anon)
}
}
func (g *graph) typ(t types.Type, parent types.Type) {
if g.seenTypes.At(t) != nil {
return
}
if t, ok := t.(*types.Named); ok && t.Obj().Pkg() != nil {
if t.Obj().Pkg() != g.pkg.Pkg {
return
}
}
g.seenTypes.Set(t, struct{}{})
if isIrrelevant(t) {
return
}
g.see(t)
switch t := t.(type) {
case *types.Struct:
for i := 0; i < t.NumFields(); i++ {
g.see(t.Field(i))
if t.Field(i).Exported() {
// (6.2) structs use exported fields
g.use(t.Field(i), t, edgeExportedField)
} else if t.Field(i).Name() == "_" {
g.use(t.Field(i), t, edgeBlankField)
} else if isNoCopyType(t.Field(i).Type()) {
// (6.1) structs use fields of type NoCopy sentinel
g.use(t.Field(i), t, edgeNoCopySentinel)
} else if parent == nil {
// (11.1) anonymous struct types use all their fields.
g.use(t.Field(i), t, edgeAnonymousStruct)
}
if t.Field(i).Anonymous() {
// does the embedded field contribute exported methods to the method set?
T := t.Field(i).Type()
if _, ok := T.Underlying().(*types.Pointer); !ok {
// An embedded field is addressable, so check
// the pointer type to get the full method set
T = types.NewPointer(T)
}
ms := g.pkg.IR.Prog.MethodSets.MethodSet(T)
for j := 0; j < ms.Len(); j++ {
if ms.At(j).Obj().Exported() {
// (6.4) structs use embedded fields that have exported methods (recursively)
g.use(t.Field(i), t, edgeExtendsExportedMethodSet)
break
}
}
seen := map[*types.Struct]struct{}{}
var hasExportedField func(t types.Type) bool
hasExportedField = func(T types.Type) bool {
t, ok := typeutil.Dereference(T).Underlying().(*types.Struct)
if !ok {
return false
}
if _, ok := seen[t]; ok {
return false
}
seen[t] = struct{}{}
for i := 0; i < t.NumFields(); i++ {
field := t.Field(i)
if field.Exported() {
return true
}
if field.Embedded() && hasExportedField(field.Type()) {
return true
}
}
return false
}
// does the embedded field contribute exported fields?
if hasExportedField(t.Field(i).Type()) {
// (6.5) structs use embedded structs that have exported fields (recursively)
g.use(t.Field(i), t, edgeExtendsExportedFields)
}
}
g.variable(t.Field(i))
}
case *types.Basic:
// Nothing to do
case *types.Named:
// (9.3) types use their underlying and element types
g.seeAndUse(t.Underlying(), t, edgeUnderlyingType)
g.seeAndUse(t.Obj(), t, edgeTypeName)
g.seeAndUse(t, t.Obj(), edgeNamedType)
// (2.4) named types use the pointer type
if _, ok := t.Underlying().(*types.Interface); !ok && t.NumMethods() > 0 {
g.seeAndUse(types.NewPointer(t), t, edgePointerType)
}
for i := 0; i < t.NumMethods(); i++ {
g.see(t.Method(i))
// don't use trackExportedIdentifier here, we care about
// all exported methods, even in package main or in tests.
if t.Method(i).Exported() {
// (2.1) named types use exported methods
g.use(t.Method(i), t, edgeExportedMethod)
}
g.function(g.pkg.IR.Prog.FuncValue(t.Method(i)))
}
g.typ(t.Underlying(), t)
case *types.Slice:
// (9.3) types use their underlying and element types
g.seeAndUse(t.Elem(), t, edgeElementType)
g.typ(t.Elem(), nil)
case *types.Map:
// (9.3) types use their underlying and element types
g.seeAndUse(t.Elem(), t, edgeElementType)
// (9.3) types use their underlying and element types
g.seeAndUse(t.Key(), t, edgeKeyType)
g.typ(t.Elem(), nil)
g.typ(t.Key(), nil)
case *types.Signature:
g.signature(t, nil)
case *types.Interface:
for i := 0; i < t.NumMethods(); i++ {
m := t.Method(i)
// (8.3) All interface methods are marked as used
g.seeAndUse(m, t, edgeInterfaceMethod)
g.seeAndUse(m.Type().(*types.Signature), m, edgeSignature)
g.signature(m.Type().(*types.Signature), nil)
}
for i := 0; i < t.NumEmbeddeds(); i++ {
tt := t.EmbeddedType(i)
// (8.4) All embedded interfaces are marked as used
g.seeAndUse(tt, t, edgeEmbeddedInterface)
}
case *types.Array:
// (9.3) types use their underlying and element types
g.seeAndUse(t.Elem(), t, edgeElementType)
g.typ(t.Elem(), nil)
case *types.Pointer:
// (9.3) types use their underlying and element types
g.seeAndUse(t.Elem(), t, edgeElementType)
g.typ(t.Elem(), nil)
case *types.Chan:
// (9.3) types use their underlying and element types
g.seeAndUse(t.Elem(), t, edgeElementType)
g.typ(t.Elem(), nil)
case *types.Tuple:
for i := 0; i < t.Len(); i++ {
// (9.3) types use their underlying and element types
g.seeAndUse(t.At(i).Type(), t, edgeTupleElement|edgeType)
g.typ(t.At(i).Type(), nil)
}
default:
panic(fmt.Sprintf("unreachable: %T", t))
}
}
func (g *graph) variable(v *types.Var) {
// (9.2) variables use their types
g.seeAndUse(v.Type(), v, edgeType)
g.typ(v.Type(), nil)
}
func (g *graph) signature(sig *types.Signature, fn types.Object) {
var user interface{} = fn
if fn == nil {
user = sig
g.see(sig)
}
if sig.Recv() != nil {
g.seeAndUse(sig.Recv().Type(), user, edgeReceiver|edgeType)
g.typ(sig.Recv().Type(), nil)
}
for i := 0; i < sig.Params().Len(); i++ {
param := sig.Params().At(i)
g.seeAndUse(param.Type(), user, edgeFunctionArgument|edgeType)
g.typ(param.Type(), nil)
}
for i := 0; i < sig.Results().Len(); i++ {
param := sig.Results().At(i)
g.seeAndUse(param.Type(), user, edgeFunctionResult|edgeType)
g.typ(param.Type(), nil)
}
}
func (g *graph) instructions(fn *ir.Function) {
fnObj := owningObject(fn)
for _, b := range fn.Blocks {
for _, instr := range b.Instrs {
ops := instr.Operands(nil)
switch instr.(type) {
case *ir.Store:
// (9.7) variable _reads_ use variables, writes do not
ops = ops[1:]
case *ir.DebugRef:
ops = nil
}
for _, arg := range ops {
walkPhi(*arg, func(v ir.Value) {
switch v := v.(type) {
case *ir.Function:
// (4.3) functions use closures and bound methods.
// (4.5) functions use functions they call
// (9.5) instructions use their operands
// (4.4) functions use functions they return. we assume that someone else will call the returned function
if owningObject(v) != nil {
g.seeAndUse(owningObject(v), fnObj, edgeInstructionOperand)
}
g.function(v)
case *ir.Const:
// (9.6) instructions use their operands' types
g.seeAndUse(v.Type(), fnObj, edgeType)
g.typ(v.Type(), nil)
case *ir.Global:
if v.Object() != nil {
// (9.5) instructions use their operands
g.seeAndUse(v.Object(), fnObj, edgeInstructionOperand)
}
}
})
}
if v, ok := instr.(ir.Value); ok {
if _, ok := v.(*ir.Range); !ok {
// See https://github.com/golang/go/issues/19670
// (4.8) instructions use their types
// (9.4) conversions use the type they convert to
g.seeAndUse(v.Type(), fnObj, edgeType)
g.typ(v.Type(), nil)
}
}
switch instr := instr.(type) {
case *ir.Field:
st := instr.X.Type().Underlying().(*types.Struct)
field := st.Field(instr.Field)
// (4.7) functions use fields they access
g.seeAndUse(field, fnObj, edgeFieldAccess)
case *ir.FieldAddr:
st := typeutil.Dereference(instr.X.Type()).Underlying().(*types.Struct)
field := st.Field(instr.Field)
// (4.7) functions use fields they access
g.seeAndUse(field, fnObj, edgeFieldAccess)
case *ir.Store:
// nothing to do, handled generically by operands
case *ir.Call:
c := instr.Common()
if !c.IsInvoke() {
// handled generically as an instruction operand
} else {
// (4.5) functions use functions/interface methods they call
g.seeAndUse(c.Method, fnObj, edgeInterfaceCall)
}
case *ir.Return:
// nothing to do, handled generically by operands
case *ir.ChangeType:
// conversion type handled generically
s1, ok1 := typeutil.Dereference(instr.Type()).Underlying().(*types.Struct)
s2, ok2 := typeutil.Dereference(instr.X.Type()).Underlying().(*types.Struct)
if ok1 && ok2 {
// Converting between two structs. The fields are
// relevant for the conversion, but only if the
// fields are also used outside of the conversion.
// Mark fields as used by each other.
assert(s1.NumFields() == s2.NumFields())
for i := 0; i < s1.NumFields(); i++ {
g.see(s1.Field(i))
g.see(s2.Field(i))
// (5.1) when converting between two equivalent structs, the fields in
// either struct use each other. the fields are relevant for the
// conversion, but only if the fields are also accessed outside the
// conversion.
g.seeAndUse(s1.Field(i), s2.Field(i), edgeStructConversion)
g.seeAndUse(s2.Field(i), s1.Field(i), edgeStructConversion)
}
}
case *ir.MakeInterface:
// nothing to do, handled generically by operands
case *ir.Slice:
// nothing to do, handled generically by operands
case *ir.RunDefers:
// nothing to do, the deferred functions are already marked use by deferring them.
case *ir.Convert:
// to unsafe.Pointer
if typ, ok := instr.Type().(*types.Basic); ok && typ.Kind() == types.UnsafePointer {
if ptr, ok := instr.X.Type().Underlying().(*types.Pointer); ok {
if st, ok := ptr.Elem().Underlying().(*types.Struct); ok {
for i := 0; i < st.NumFields(); i++ {
// (5.2) when converting to or from unsafe.Pointer, mark all fields as used.
g.seeAndUse(st.Field(i), fnObj, edgeUnsafeConversion)
}
}
}
}
// from unsafe.Pointer
if typ, ok := instr.X.Type().(*types.Basic); ok && typ.Kind() == types.UnsafePointer {
if ptr, ok := instr.Type().Underlying().(*types.Pointer); ok {
if st, ok := ptr.Elem().Underlying().(*types.Struct); ok {
for i := 0; i < st.NumFields(); i++ {
// (5.2) when converting to or from unsafe.Pointer, mark all fields as used.
g.seeAndUse(st.Field(i), fnObj, edgeUnsafeConversion)
}
}
}
}
case *ir.TypeAssert:
// nothing to do, handled generically by instruction
// type (possibly a tuple, which contains the asserted
// to type). redundantly handled by the type of
// ir.Extract, too
case *ir.MakeClosure:
// nothing to do, handled generically by operands
case *ir.Alloc:
// nothing to do
case *ir.UnOp:
// nothing to do
case *ir.BinOp:
// nothing to do
case *ir.If:
// nothing to do
case *ir.Jump:
// nothing to do
case *ir.Unreachable:
// nothing to do
case *ir.IndexAddr:
// nothing to do
case *ir.Extract:
// nothing to do
case *ir.Panic:
// nothing to do
case *ir.DebugRef:
// nothing to do
case *ir.BlankStore:
// nothing to do
case *ir.Phi:
// nothing to do
case *ir.Sigma:
// nothing to do
case *ir.MakeMap:
// nothing to do
case *ir.MapUpdate:
// nothing to do
case *ir.MapLookup:
// nothing to do
case *ir.StringLookup:
// nothing to do
case *ir.MakeSlice:
// nothing to do
case *ir.Send:
// nothing to do
case *ir.MakeChan:
// nothing to do
case *ir.Range:
// nothing to do
case *ir.Next:
// nothing to do
case *ir.Index:
// nothing to do
case *ir.Select:
// nothing to do
case *ir.ChangeInterface:
// nothing to do
case *ir.Load:
// nothing to do
case *ir.Go:
// nothing to do
case *ir.Defer:
// nothing to do
case *ir.Parameter:
// nothing to do
case *ir.Const:
// nothing to do
case *ir.Recv:
// nothing to do
case *ir.TypeSwitch:
// nothing to do
case *ir.ConstantSwitch:
// nothing to do
case *ir.SliceToArrayPointer:
// nothing to do
default:
lint.ExhaustiveTypeSwitch(instr)
}
}
}
}
// isNoCopyType reports whether a type represents the NoCopy sentinel
// type. The NoCopy type is a named struct with no fields and exactly
// one method `func Lock()` that is empty.
//
// FIXME(dh): currently we're not checking that the function body is
// empty.
func isNoCopyType(typ types.Type) bool {
st, ok := typ.Underlying().(*types.Struct)
if !ok {
return false
}
if st.NumFields() != 0 {
return false
}
named, ok := typ.(*types.Named)
if !ok {
return false
}
if named.NumMethods() != 1 {
return false
}
meth := named.Method(0)
if meth.Name() != "Lock" {
return false
}
sig := meth.Type().(*types.Signature)
if sig.Params().Len() != 0 || sig.Results().Len() != 0 {
return false
}
return true
}
func walkPhi(v ir.Value, fn func(v ir.Value)) {
phi, ok := v.(*ir.Phi)
if !ok {
fn(v)
return
}
seen := map[ir.Value]struct{}{}
var impl func(v *ir.Phi)
impl = func(v *ir.Phi) {
if _, ok := seen[v]; ok {
return
}
seen[v] = struct{}{}
for _, e := range v.Edges {
if ev, ok := e.(*ir.Phi); ok {
impl(ev)
} else {
fn(e)
}
}
}
impl(phi)
}
go-tools-2021.1.2/unused/unused_test.go 0000664 0000000 0000000 00000006557 14143223131 0017705 0 ustar 00root root 0000000 0000000 package unused
import (
"go/types"
"strings"
"testing"
"golang.org/x/tools/go/analysis/analysistest"
)
type expectation bool
const (
shouldBeUsed = true
shouldBeUnused = false
)
func (exp expectation) String() string {
switch exp {
case shouldBeUsed:
return "used"
case shouldBeUnused:
return "unused"
default:
panic("unreachable")
}
}
func check(t *testing.T, res *analysistest.Result) {
type key struct {
file string
line int
}
want := map[key]expectation{}
files := map[string]struct{}{}
isTest := false
for _, f := range res.Pass.Files {
filename := res.Pass.Fset.Position(f.Pos()).Filename
if strings.HasSuffix(filename, "_test.go") {
isTest = true
break
}
}
for _, f := range res.Pass.Files {
filename := res.Pass.Fset.Position(f.Pos()).Filename
if !strings.HasSuffix(filename, ".go") {
continue
}
files[filename] = struct{}{}
for _, cgroup := range f.Comments {
commentLoop:
for _, c := range cgroup.List {
text := strings.TrimPrefix(c.Text, "//")
if text == c.Text {
continue // not a //-comment
}
fields := strings.Fields(text)
posn := res.Pass.Fset.Position(c.Pos())
for _, field := range fields {
switch field {
case "used", "unused", "used_test", "unused_test":
default:
continue commentLoop
}
}
for _, field := range fields {
switch field {
case "used":
if !isTest {
want[key{posn.Filename, posn.Line}] = shouldBeUsed
}
case "unused":
if !isTest {
want[key{posn.Filename, posn.Line}] = shouldBeUnused
}
case "used_test":
if isTest {
want[key{posn.Filename, posn.Line}] = shouldBeUsed
}
case "unused_test":
if isTest {
want[key{posn.Filename, posn.Line}] = shouldBeUnused
}
}
}
}
}
}
checkObjs := func(objs []types.Object, state expectation) {
for _, obj := range objs {
posn := res.Pass.Fset.Position(obj.Pos())
if _, ok := files[posn.Filename]; !ok {
continue
}
k := key{posn.Filename, posn.Line}
exp, ok := want[k]
if !ok {
t.Errorf("unexpected %s object at %s", state, posn)
continue
}
delete(want, k)
if state != exp {
t.Errorf("object at %s should be %s but is %s", posn, exp, state)
}
}
}
ures := res.Result.(Result)
checkObjs(ures.Used, shouldBeUsed)
checkObjs(ures.Unused, shouldBeUnused)
for key, b := range want {
var exp string
if b {
exp = "used"
} else {
exp = "unused "
}
t.Errorf("did not see expected %s object %s:%d", exp, key.file, key.line)
}
}
func TestAll(t *testing.T) {
dirs := []string{
"tests",
"alias",
"anonymous",
"blank",
"cgo",
"consts",
"conversion",
"cyclic",
"defer",
"elem",
"embedded_call",
"embedding",
"embedding2",
"exported_fields",
"exported_fields_main",
"exported_method_test",
"fields",
"functions",
"ignored",
"interfaces",
"interfaces2",
"linkname",
"main",
"mapslice",
"methods",
"named",
"nested",
"nocopy",
"nocopy-main",
"pointer-type-embedding",
"pointers",
"quiet",
"selectors",
"switch_interface",
"tests",
"tests-main",
"type-dedup",
"type-dedup2",
"type-dedup3",
"types",
"unused-argument",
"unused_type",
"variables",
}
results := analysistest.Run(t, analysistest.TestData(), Analyzer.Analyzer, dirs...)
for _, res := range results {
check(t, res)
}
}
