fix calls in generic bodies, delay typecheck when no overloads match

[metagn]

fixes #19916, fixes #20514, fixes #20937, fixes #19284, fixes #19365, refs 7fdf299

In generic bodies, the compiler hard-compiles calls in array/range/when static expression parts, including with generic parameter arguments which cannot reasonably be evaluated and have to be special cased in some places in the compiler (example in semLowHigh). There was no such special casing for calls in sigmatch/semcall, instead there was some weird workaround involving not instantiating generic calls in generic bodies which breaks a lot of code that should work.

This workaround is now removed and generic calls are always instantiated. In order for this to work, special casing has also been added to sigmatch/semcall so that calls with unresolved generic parameters don't match typedesc parameters of procs, and calls with no matching overloads delay their typechecking to instantiation time.

tyGenericParam is added to types.isCompileTimeOnly to make T; U: static T work, due to how static T behaves the same as static foo() and just converts to a static type when the expression returns a typedesc. Note that static[T] is not affected and worked before.

There is was also a new untyped foo() syntax (inspired by the "untyped escape hatch" in nim-lang/RFCs#168) to stop hard compilation in generic bodies and delay to instantiation time when the compiler can't delay it by itself. But this isn't needed currently in this PR and can be detached from it (although it might be useful to work around future bugs, like (U + 1) * 2 not working). Update: It was detached from the PR.

[Araq]

Oh yes, that is sweet!

[metagn]

This change exists in this PR for the sole purpose of making T; U: static T work (though might be more correct anyway). In any case the compiler treats static T the same as static foo() and evaluates it as a constant expression which returns static[T]. static[T] on the other hand goes through semStaticType in semtypes which doesn't have a reason to fail with generic params.

One might think to add elif op.id == ord(wStatic): result = semStaticType(...) here instead, but this might not be correct and could break some code and I don't want to complicate this PR.

Edit: I believe this also fixes #15760, will add test case doesn't

[metagn]

The main issue here is that the compiler hard-compiles calls in array/range/when (not tested) static expression parts, including with generic parameter arguments which cannot reasonably be evaluated and have to be special cased in some places in the compiler (example in semLowHigh). This special casing is not properly performed for calls in sigmatch/semcall, instead there is some weird workaround involving not instantiating generic calls which breaks a lot of code that should work.

The reason statics work without this workaround is we already know their type when they're constrained, i.e. when T: static int we can compile T + 1 early without problem. When they're not constrained, like T; U: static T, the same problem is there.

The new untyped foo() syntax prevents this hard compilation, but the user has to think to use it without any good suggestions, and the compiler has feigned automatically detecting it so far so maybe it should properly do it. This untyped also doesn't seem to always work with the old workaround.

Right now I am not able to either make the compiler smarter on the broken cases or make the call to use nkStaticExpr on every call node in generic range types and lose information people might depend on/performance. For this reason this behavior is now opt-in, but currently this is done with an experimental switch which won't work if it's turned on at the type declaration but not at the site of the instantiation. Maybe it can be attached to the type instead, i.e. Foo[T] {.instantiateCalls.} = ..., or this is inferred in a context with the experimental feature turned on. Broken cases work

[metagn]

OK I now made it so:

1. unresolved generic parameters can't be passed to typedesc arguments (sigmatch change)
2. calls without matching overloads get a tyFromExpr type instead of erroring in generic contexts (semcall change, with required followups in semexprs)

This accomplishes "making the compiler smarter" to make the old cases still work. So we don't need any opting in anymore.

This also means the untyped feature is not needed in the scope of this proc, but might be needed to workaround bugs not covered here down the line (just realized (U + 1) * 2 is one such bug). I can either remove it to maybe put in another PR later maybe with an RFC (it's a small change), or keep it and document it etc (without making much noise).

[Araq]

I can either remove it to maybe put in another PR

What would this removal look like?

[metagn]

This diff from semexprs gets removed:

   of tyUntyped: 
     if c.inGenericContext > 0: 
       # could add `and efDetermineType in flags`, but no flags param 
       result = n[1] 
       result.typ = makeTypeFromExpr(c, result.copyTree) 
       return 
     else: 
       localError(c.config, n.info, "illegal type conversion to '$1'" % typeToString(targetType)) 
   of tyAnything, tyTyped:

And it's used once in a test which is a copy of another test without it. That's it.

[Araq]

So remove it please.

[metagn]

Done

[github-actions]

Thanks for your hard work on this PR!
The lines below are statistics of the Nim compiler built from 894a19c

Hint: mm: orc; opt: speed; options: -d:release
167854 lines; 12.710s; 610.969MiB peakmem