Resolver & Type Classes Tracking Issue

[FlandiaYingman]

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

• Handle cyclic resolution

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

• Resolution possibly leading to more symbol resolution.

  fun foo[A](using foo: Foo[A]): A
  
  use Foo[List]
  foo.map

• 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)

• Reused mutable terms, mostly of UCS normalization. (see Move All Resolution to the Resolution Stage #297 (comment)).

• Move selections' symbol resolution to the resolution phase.

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

Completed Tasks

• Local functions as module methods (as their definitions always exist).

• It resolves implicit application through Sel and SynthSel (because they may lead to an implicit module method call), but Ref.

  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))