Dimi Racordon

Consider the following program: ```hylo trait P { type X fun foo() } trait Q {} extension P where X: Q { fun foo() {} } type B: P {...

Compile this program: ``` fun use(_ x: Any) {} public fun main() { let a: Any = 0 as _ use(a) } ``` The compiler crashes in `FunctionReference.swift:20` complaining about...

The parsing of attributes deserves some refactoring. In particular, it would be good to check for their wellformedness in one single place rather than scattering tests across different compiler phases.

`TypeChecker.lookup(unqualified:in:)` is called very often. It is possible we could speedup name resolution by memoizing its results.

Mutation markers should be required by the compiler on every expression appearing as argument to an `inout` or `set` parameter. For example, this program should not compile: ``` public fun...

Compile addressors efficiently

4

Addressors are subscripts that project an existing value rather than a synthetic one. Such subscripts should be compiled as direct function calls and not require any continuation. For example: ```swift...

Implement '@autoclosure'

1

The feature should work similarly as it does in [Swift](https://docs.swift.org/swift-book/documentation/the-swift-programming-language/closures/#Autoclosures). Note: `@autoclosure` is necessary to properly implement shortcut behavior in `Bool.infix&&`

This seems incorrect: https://github.com/hylo-lang/hylo/blob/91768bdc289bbc5e11f55c56489c0b47129b01f8/Sources/FrontEnd/TypeChecking/TypeChecker.swift#L5155 I suppose the intent was to say that a function `(A) -> B` is _less_ specific than a function `(T) -> B`, which isn't the case...

Reproducer: ```swift type A { public memberwise init } typealias B = A trait T {} conformance B: T { public fun h() { let p = self check(p) //

Refactor the "specialization" of members during conformance checking

1

During conformance checking, the type checker tries to match each requirement of the trait to an implementation of the conforming type. That is done by: 1. inferring the type a...