feat: preserve named types in semantic types and when translating between Motoko and Candid

[crusso]

Inspired by discussion with @giorgiopiatti-dfinity

Both Motoko and Candid support syntactically named types for more informative type (especially function) signatures.

Eg.

(x: Int, y:Int) -> (z:int) 

vs.

(Int, Int) -> (Int)

These are purely syntactic and erased from the syntax before type checking. They are not preserved by type checking nor by translation to Candid.

This PR attempts to preserve name types throughout front-end type checking to produce better Candid and more informative types. Named types are erased, along with type fields, in early IR pass erase_typ_fields, so most ir passes are unaffected.

This requires fairly extensive surgery to ignore names in various operations on types, e.g. sub-typing and type equivalence.

Example Candid output:

names.mo:

actor {

  /// named
  public func named(x:Nat, y:Nat) : async (r : Nat) {
    x + y
  };

  /// anon
  public func anon(_ : Nat, _ : Nat) : async Nat {
    0
  };

  /// record
  public func record({x:Nat; y:Nat}) : async {r:Nat} {
    {r = x + y}
  };

  /// function arg/ret
  public func f(named : shared (x:Nat, y:Nat) -> async (r : Nat)) :
     async (unamed : shared (Nat, Nat) -> async Nat) {
    named
  };

  /// actor arg/ret
  public func g(A :
    actor {
      named : shared (x:Nat, y:Nat) -> async (r : Nat);
      anon : shared (Nat, Nat) -> async Nat
     }) :
     async (actor {
      named : shared (Nat, Nat) -> async Nat;
      anon : shared (x:Nat, y:Nat) -> async (r : Nat)
     }) {
    A
  };

  /// escape candid keywords
  public func escape(int : Int, bool : Bool, service : actor {}) :
   async (int : Int, bool : Bool, service : actor {}) {
    (int, bool, service)
  }
}

now produces Candid:

service : {
  /// anon
  anon: (nat, nat) -> (nat);
  /// escape candid keywords
  escape: ("int": int, "bool": bool, "service": service {}) -> 
    ("int": int, "bool":  bool, "service": service { });
  /// function arg/ret
  f: (named: func (x: nat, y: nat) -> (r: nat)) -> 
       (unamed: func (nat, nat) -> (nat));
  /// actor arg/ret
  g: (A:
   service {
     anon: (nat, nat) -> (nat);
     named: (x: nat, y: nat) -> (r: nat);
   }) ->
   (service {
      anon: (x: nat, y: nat) -> (r: nat);
      named: (nat, nat) -> (nat);
    });
  /// named
  named: (x: nat, y: nat) -> (r: nat);
  /// record
  "record": (record {
               x: nat;
               y: nat;
             }) -> (record {r: nat;});
}

In comparison, master branch produces:

service : {
  /// anon
  anon: (nat, nat) -> (nat);
  /// escape candid keywords
  escape: (int, bool, service {
                      }) -> (int, bool, service {
                                        });
  /// function arg/ret
  f: (func (nat, nat) -> (nat)) -> (func (nat, nat) -> (nat));
  /// actor arg/ret
  g: (service {
        anon: (nat, nat) -> (nat);
        named: (nat, nat) -> (nat);
      }) -> (service {
               anon: (nat, nat) -> (nat);
               named: (nat, nat) -> (nat);
             });
  /// named
  named: (nat, nat) -> (nat);
  /// record
  "record": (record {
               x: nat;
               y: nat;
             }) -> (record {r: nat;});
}

To avoid information overload, we suppress names under object fields, tags and options.

TODO:
[x] add space before around colon (current is consistent with current formatting of candid fields/tags)
[x] suppress names under object fields, tags and options (too much information)

NOTE: If we think this is providing too much info in ordinary error messages, a less radical approach would be to suppress names on output of Motoko types (always/sometimes), and only use them when translating to Candid.

[crusso]

This is what base/OrderedMap renders as:

module {
    type Map<K, V> = {root : Tree<K, V>; size : Nat};
    type Operations<K> =
      {
        all : <V>(m : Map<K, V>, pred : (K, V) -> Bool) -> Bool;
        contains : <V>(m : Map<K, V>, key : K) -> Bool;
        delete : <V>(m : Map<K, V>, key : K) -> Map<K, V>;
        empty : <V>() -> Map<K, V>;
        entries : <V>(m : Map<K, V>) -> Iter__1<(K, V)>;
        entriesRev : <V>(m : Map<K, V>) -> Iter__1<(K, V)>;
        foldLeft :
          <Value, Accum>(map : Map<K, Value>, base : Accum,
                         combine : (Accum, K, Value) -> Accum) ->
            Accum;
        foldRight :
          <Value, Accum>(map : Map<K, Value>, base : Accum,
                         combine : (K, Value, Accum) -> Accum) ->
            Accum;
        fromIter : <V>(i : Iter__1<(K, V)>) -> Map<K, V>;
        get : <V>(m : Map<K, V>, key : K) -> ?V;
        keys : <V>(m : Map<K, V>) -> Iter__1<K>;
        map : <V1, V2>(m : Map<K, V1>, f : (K, V1) -> V2) -> Map<K, V2>;
        mapFilter :
          <V1, V2>(m : Map<K, V1>, f : (K, V1) -> ?V2) -> Map<K, V2>;
        maxEntry : <V>(m : Map<K, V>) -> ?(K, V);
        minEntry : <V>(m : Map<K, V>) -> ?(K, V);
        put : <V>(m : Map<K, V>, key : K, value : V) -> Map<K, V>;
        remove : <V>(m : Map<K, V>, key : K) -> (Map<K, V>, ?V);
        replace : <V>(m : Map<K, V>, key : K, value : V) -> (Map<K, V>, ?V);
        size : <V>(m : Map<K, V>) -> Nat;
        some : <V>(m : Map<K, V>, pred : (K, V) -> Bool) -> Bool;
        validate : <V>(m : Map<K, V>) -> ();
        vals : <V>(m : Map<K, V>) -> Iter__1<V>
      };
    Make : <K>(compare : (K, K) -> Order) -> Operations<K>;
    Operations : <K>(compare : (K, K) -> Order) -> Operations<K>
  }

[github-actions]

Comparing from db60d5a to 65c3def:
In terms of gas, no changes are observed in 5 tests.
In terms of size, no changes are observed in 5 tests.

[crusso]

Fixes #4344.

[luc-blaeser]

Thank you for doing this PR. Let's merge.

[ggreif]

LGTM! Minor nits only.