feat: add syntax for specifying function type environments

[alexvitkov]

Description

Problem*

Work towards #2334

Summary*

In #2335 we allowed higher order with closure arguments to pass type-checking -- this PR implements the monomorphizer changes needed to make those calls work.

overridden_types

A new property overridden_types is added in the Monomorphizer. It allows us to change the type of an expression, for the currently monomorphized function instance only. It's used for adding capture environments to function types.

propagate.rs

A function propagate_overridden_types_expr is added in a new file - propagate.rs. After we override the type of a parameter to add a capture group, we need to walk the body of the function and also update the types of all expressions where it is used.

Documentation

• This PR requires documentation updates when merged.

  • I will submit a noir-lang/docs PR.
  • I will request for and support Dev Rel's help in documenting this PR.

Additional Context

PR Checklist*

• I have tested the changes locally.
• I have formatted the changes with Prettier and/or cargo fmt on default settings.

[jfecher]

I'm not confidant this approach with overridden_types and manually trying to propagate modified types during monomorphization will be a good base to build upon for subsequent features, even if we want to replace it eventually.

It looks like we can only pass in closures directly to functions as arguments in this PR (e.g. passing them in a tuple does not work). Although the later does issue a type error instead of panicking.

I think exposing the environment type parameter to users would be less of a change and allow us to implement functions accepting closures, even nested within other types, in addition to functions returning closures in one go.

[alexvitkov]

I understand, I'll add support for the syntax you mentioned in the issue - fn[env](params) -> ret.

[alexvitkov]

I've made the following changes:

• Reverted all the changes relating to overridden_types
• Reverted feat: Allow calling higher-order functions with closures #2335, as letting calls to higher order fns with closures pass typechecking doesn't make sense anymore
• Implemented the syntax fn[envtype1, envtype2, ...](param1, ...) -> ret and added tests
• Minor tweak in function_call in Monomorphizer to handle foo()() if foo() is a closure (this case wasn't possible before, and without this change we would rewrite it to foo().1(foo().0) which calls foo twice)

[jfecher]

Thanks! Let's add the environment generics change (mentioned in a comment below) as a separate PR. That should get us all the way towards releasing closures as a feature in Noir.

There's a minor style suggestion but it's not a blocker for this PR.