Go 1.17 support #1043
Merged
Go 1.17 support #1043
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
flimzy
force-pushed
the
wip-go1.17
branch
13 times, most recently
from
e857b8a to
f6f0eef
Compare
flimzy
force-pushed
the
wip-go1.17
branch
4 times, most recently
from
f8407a0 to
f6f0eef
Compare
|
Recent changes in the To reproduce: This can be reproduces with a simple test case: func main() {
x := []int{}
t := reflect.TypeOf(x)
_ = reflect.New(t)
} |
flimzy
force-pushed
the
wip-go1.17
branch
5 times, most recently
from
4c3ccf5 to
d767a4d
Compare
nevkontakte
reviewed
Aug 4, 2021
| import "testing" | ||
|
|
||
| func TestScalarMultDistributesOverAdd(t *testing.T) { | ||
| t.Skip("slow") // Times out, takes ~13 minutes |
There was a problem hiding this comment.
Not related to this PR per se, but thinking out loud. One reason I heard for people using GopherJS was access to the crypto library, and our crypto in incredibly slow. I did a little profiling and it seems to all boil down to math/big being really slow with our implementation of slices. I couldn't think of an easy way to improve the situation, but these tests shall serve as additional motivation to try and optimize it further.
nevkontakte
force-pushed
the
wip-go1.17
branch
from
4e4fa4b to
9a879c2
Compare
And slightly refactor CheckGoVersion to require less manual intervention for each version change.
Array pointers are the only kind of pointer considered a "wrapped", so they need to be handled appropriately. At runtime an array pointer is represented by a reference to the JavaScript native array object, so we only need to copy the reference and couple it with the desired Go type. It will be boxed into the new Go type if/when the compiler needs it down the road.
Upstream uses a conversion to unsafeheader.Slice, which isn't supported by GopherJS. Using Value.Len() is preferrable, since we already override it to provide compatibility. If/when golang/go#48346 gets into the stable release, this patch will no longer be necessary.
Complete support for slice-to-array conversion.
Since JavaScript runtime is single-threaded, there isn't much special logic to be done. However, it is important that all these functions never call anything potentially blocking to make sure the goroutine is not interrupted in a middle of an atomic operation.
sync/atomic: Implement new Swap and CompareAndSwap methods of Value.
This pulls in a few select functions from Go 1.16, which were optimized and thus made unsafe in Go 1.17. golang/go#47342 should render this change obsolete if/when implemented.
Get `hash/maphash` to work again
This package seems to be related to the new register-based ABI in Go 1.17, which is completely irrelevant for GopherJS.
The fix is two-fold:
1. `disableSplice` is initialized with `(*bool)(nil)` to work around
#1060.
2. Skipped `TestSplicePipePool`, which relies in runtime features
GopherJS doesn't support.
Fix standard library test failures in `internal` packages.
This fixes golang/go#44830 for GopherJS.
In the following example type T is *types.Named, not *types.Pointer, but
the underlying type is:
```go
type T *struct{ y int }
var q T = &struct{ y int }{}
q.y = 7
```
The panic was detected by gorepo test `fixedbugs/issue23017.go`.
GopherJS breaks lhs expression evaluation order defined by the spec. Unfortunately, it's not easy to fix and would likely generate a lot more code for multi-assignments. An efficient fix would require writing some sort of analysis to determine if assignments are likely to influence each other, and at the moment I can't think of how such analysis would work. Without it we would have to create a whole bunch of extra temporary variables for any multi-assignment, which will likely lead to a significant increase in the artifact size. Considering nobody reported this issue so far, I'm inclined to punt on this issue for now. #1063 tracks this bug.
Resolve the two remaining gorepo test failures.
This change improves Go version detection for the provided GOROOT by falling back to `go version` command output if VERSION file doesn't exist (fixes #1018). If GOROOT-based version detection failed, it falls back further to the Go version from GopherJS release or a minor version in "go1.x" format. The detected value is then injected by the compiler into the generated JS file and picked up by the `runtime` package.
runtime: Version() returns Go version provided by the compiler.
This isn't really sufficient to test the implementation correctness perfectly, but it is a sufficient smoke test for GopherJS, and it cuts the test runtime substantially.
Un-skip a few tests from crypto libraries.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Go 1.17 is on the way!
This PR tracks progress toward adding Go 1.17 support to GopherJS.
TODO:
runtime.Version()dynamically at compile time. This changed from 1.16 to 1.17 upstream, and is now handled by the linker in 1.17, which we don't have, so we need to invent a new solution.crypto/ed25519package.hash/maphashimplementation to work without pointer arithmetic. Related: hash/maphash: Provide apuregoimplementation golang/go#47342 (comment)math/bigto avoid constant overflow.reflect(see Go 1.17 support #1043 (comment) for details)//go:buildlines are understood properlyfmtexamples are failing for 1.17fixedbugs/issue23017.gocauses a compiler panicOut of scope for this PR (but may be considered as part of future work):
gopherjs run