-
-
Notifications
You must be signed in to change notification settings - Fork 1.5k
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
SIGSEGV when return type depends on a static[T]
parameter
#8545
Comments
The SIGSEGV crash is a regression due to the not nil changes. On 0.18.0 the output is: template bar(a: static[bool]): untyped = int
proc foo(a: static[bool]): bar(a) = 1
echo foo(true)
# static.nim(3, 31) Error: type mismatch: got <static[bool]>
# but expected one of:
# template bar(a: static[bool]): untyped
#
# expression: bar(a)
I think the issue on stable was fixed already by the flurry of static[int] fixes and there is no need to log it. (On stable this fails with the same error but compiles properly on devel) |
@mratsim just curious: what's the policy on logging and fixing bugs in stable? IMO, given scarce resources, shouldn't we just focus on logging / fixing bugs in devel? (maybe at exception of critical security bugs, idk)
what do you mean by that? |
Sorry I was completely unclear. Regarding the following snippet: template bar(a: static[bool]): untyped = int
proc foo(a: static[bool]): bar(a) = 1
echo foo(true)
# static.nim(3, 31) Error: type mismatch: got <static[bool]>
# but expected one of:
# template bar(a: static[bool]): untyped
#
# expression: bar(a)
It reminds me of #7730 and #7746 where less traveled compiler codepaths crashed with SIGSEGV due to the new Regarding bugs in stable, the solution is just to release either 0.x.2 or 0.x+1.0 depending on the changes. |
Update:
|
also, this works too: when defined(case5):
proc foo(a: static[bool]): bar(static(a)) = 1 before closing, we need a test case with case1,2,4,5 (can be simply tests/misc/t8545.nim) |
Co-authored-by: Timothee Cour <timothee.cour2@gmail.com>
Co-authored-by: Timothee Cour <timothee.cour2@gmail.com>
fixes nim-lang#8406, fixes nim-lang#8551, refs nim-lang#8545, refs nim-lang#22607
fixes nim-lang#8406, fixes nim-lang#8551, refs nim-lang#8545, refs nim-lang#22607
fixes nim-lang#8406, fixes nim-lang#8551, refs nim-lang#8545, refs nim-lang#22607
fixes nim-lang#8406, fixes nim-lang#8551, refs nim-lang#8545, refs nim-lang#22607
…n fixes (#24005) fixes #4228, fixes #4990, fixes #7006, fixes #7008, fixes #8406, fixes #8551, fixes #11112, fixes #20027, fixes #22647, refs #23854 and #23855 (remaining issue fixed), refs #8545 (works properly now with `cast[static[bool]]` changed to `cast[bool]`), refs #22342 and #22607 (disabled tests added), succeeds #23194 Parameter and return type nodes in generic procs now undergo the same `inGenericContext` treatment that nodes in generic type bodies do. This allows many of the fixes in #22029 and followups to also apply to generic proc signatures. Like #23983 however this needs some more compiler fixes, but this time mostly in `sigmatch` and type instantiations. 1. `tryReadingGenericParam` no longer treats `tyCompositeTypeClass` like a concrete type anymore, so expressions like `Foo.T` where `Foo` is a generic type don't look for a parameter of `Foo` in non-generic code anymore. It also doesn't generate `tyFromExpr` in non-generic code for any generic LHS. This is to handle a very specific case in `asyncmacro` which used `FutureVar.astToStr` where `FutureVar` is generic. 2. The `tryResolvingStaticExpr` call when matching `tyFromExpr` in sigmatch now doesn't consider call nodes in general unresolved, only nodes with `tyFromExpr` type, which is emitted on unresolved expressions by increasing `c.inGenericContext`. `c.inGenericContext == 0` is also now required to attempt instantiating `tyFromExpr`. So matching against `tyFromExpr` in proc signatures works in general now, but I'm speculating it depends on constant folding in `semExpr` for statics to match against it properly. 3. `paramTypesMatch` now doesn't try to change nodes with `tyFromExpr` type into `tyStatic` type when fitting to a static type, because it doesn't need to, they'll be handled the same way (this was a workaround in place of the static type instantiation changes, only one of the fields in the #22647 test doesn't work with it). 4. `tyStatic` matching now uses `inferStaticParam` instead of just range type matching, so `Foo[N div 2]` can infer `N` in the same way `array[N div 2, int]` can. `inferStaticParam` also disabled itself if the inferred static param type already had a node, but `makeStaticExpr` generates static types with unresolved nodes, so we only disable it if it also doesn't have a binding. This might not work very well but the static type instantiation changes should really lower the amount of cases where it's encountered. 5. Static types now undergo type instantiation. Previously the branch for `tyStatic` in `semtypinst` was a no-op, now it acts similarly to instantiating any other type with the following differences: - Other types only need instantiation if `containsGenericType` is true, static types also get instantiated if their value node isn't a literal node. Ideally any value node that is "already evaluated" should be ignored, but I'm not sure of a better way to check this, maybe if `evalConstExpr` emitted a flag. This is purely for optimization though. - After instantiation, `semConstExpr` is called on the value node if `not cl.allowMetaTypes` and the type isn't literally a `static` type. Then the type of the node is set to the base type of the static type to deal with `semConstExpr` stripping abstract types. We need to do this because calls like `foo(N)` where `N` is `static int` and `foo`'s first parameter is just `int` do not generate `tyFromExpr`, they are fully typed and so `makeStaticExpr` is called on them, giving a static type with an unresolved node.
BUG: case2 below should work, but it gives SIGSEGV
NOTE: use case reduced from #8531 (comment)
The text was updated successfully, but these errors were encountered: