Resolver & Type Classes Tracking Issue

[FlandiaYingman]

This issue tracks the problems that are neither urgent nor pressing related to the resolver & type classes feature.

Summer UROP

• Unsoundness of partial application.
• Support explicitly specifying contextual argument.
• Change use keyword into a predef function.
• Reused mutable terms, mostly of UCS normalization. (see Move All Resolution to the Resolution Stage #297 (comment)).

---

• Separate Value.Ref into two cases to make fewer illegal states representable.
• Term.Resolved #343 (comment)

Later

• Handle cyclic resolution

  M.List.map
  
  module M with
    val List: M2.List = M2.List
  
  module M2 with
    val List: M.List = M.List

• Move selections' symbol resolution to the resolution phase and refactor the resolvedSymbol part.

  • Before that, move UCS normalization to/after the resolution phase.

Completed Tasks

- [x] Resolution possibly leading to more symbol resolution. ```fs fun foo[A](using foo: Foo[A]): A

use Foo[List]
foo.map

- [x] Local functions as module methods (as their definitions always exist).

- [x] It resolves implicit application through `Sel` and `SynthSel` (because they may lead to an implicit module method call), but `Ref`.
```fs
Sel(M, f) // is resolved to App(Sel(M, f), CtxArgs)
SynthSel(M, f) // is resolved to App(SynthSel(M, f), CtxArgs)
Ref(M.f) // is not, and is expected to be, resolved to App(Ref(M.f), CtxArgs)

• Module information of definitions that returns a module

  module A with
    fun f() = 2
  
  module B with
    val a: module A = A
  
  print(B.a) // B.a should be a module, and should be rejected passing to a regular parameter

• Syntax def f(using Type) works but def f(using Type1, Type2) doesn't work. #274

• Move all module method checking logic to the resolution stage. #294

• Add symbols to all possibly moduleful terms. (Move all module method checking logic to the resolution stage. #294 (comment))

• Support use[...] syntax as in (see Handler runtime improvements #282 (comment))

  fun fib(using Yield[Int]) =
    fun inner(a, b) =
      use[Yield].yield(a)
      inner(b, a + b)
    inner(0, 1)