Refactor and improve type checking.

[mikebenfield]

Superfluous contants like ADDRESS_TYPE in checker.rs
are removed, along with some of the assert_*_type methods.

TypeChecker's implementation of ExpressionVisitor
has Output = Type rather than Output = Some(Type),
and its methods return Type::Err on errors rather than None.

Many functions in that implementation have a simpler implementation
with fewer levels of nesting.

Introduced new errors for TypeCheckerError:

type_should_be2 is a replacement for type_should_be
with a better message. Also various _mismatch errors
for operators with incorrectly typed operands.

Introduce equal_user for comparing whether two
types are equal as seen by the user - only difference between
the older eq_flat is it takes into account current
program name when comparing composite types

Display CompositeType with program name if present.

Parse CompositeType without program name if it's not present.

Catch type errors previously not caught:

• transition call after async function call (this should eventually
  be allowed, but it will require changes to codegen)

• Abs operand type

• Binary operation operand type

• Comparing record types with the same name but different programs

• Ternary conditional operands not being the same type

(Some of these errors were caught before only in the case that their
visitor received an expected type as addtional input.)

[d0cd]

This should work right, because the size of Foo will be less than 128 bits. This particular instance actually may be too large, but some structs may fit. May be an entirely new feature.

[mikebenfield]

Actually I'm not sure any structs will fit. There's a lot of overhead in the bitwise representation of structs. For each member, its name is encoded as a field. I don't think any struct will be encoded as less than 280 bits.

[d0cd]

Identifiers are length-prefixed so for small enough structs, you'd be able to get them to fit.

#[test]
    fn test_size_in_bits() {
        let plaintext = Plaintext::<CurrentNetwork>::from_str("{ x: 1u8 }").unwrap();
        let size_in_bits = plaintext.to_bits_le().len();
        assert_eq!(size_in_bits, 76);
    }

A simpler approach could be to allow structs and arrays, but issue a compiler warning that their may be a runtime failure if the struct or array is too big.
Possibly work for a different PR.

[mikebenfield]

I see. In that case maybe yeah I'll leave it to a runtime error.

[d0cd]

In this case, Foo exceeds the size of a u64, so it should not be allowed.

[mikebenfield]

I don't follow. It already is being disallowed, isn't it?

[d0cd]

Oops, meant it as a follow on thought for the previous comment.
That structs and arrays should in general be allowed, but this one is clearly oversized.

[d0cd]

LGTM! Could you add a short blurb in the PR describing what it does, just for completeness?

Good to merge after that!

[mikebenfield]

I've copied the commit message to the PR comment.