/// Return the effective type of a node after any coercion applied by

/// the resolver. `lowerExpr` already materializes the coercion in the

/// IL value, so the lowerer must use the post-coercion type when

/// choosing how to compare or store that value.

    let ty = try typeOf(self, node);

    if let coerce = resolver::coercionFor(self.low.resolver, node) {

        if let case resolver::Coercion::OptionalLift(optTy) = coerce {

            return optTy;

        }

/// Verifies argument count matches field count, and that each argument is

/// assignable to its corresponding field type.

unsafe fn checkRecordConstructorArgs 'arena (self: &mut Resolver 'arena, node: *ast::Node, args: *[*ast::Node], recInfo: RecordType)

    throws (ResolveError)

{

    for arg, i in args {

        let fieldType = recInfo.fields[i].fieldType;

        try checkAssignable(self, arg, fieldType);

    }

}

/// Check that the argument count of a constructor pattern or call matches the record field count.

    }

}

/// Helper for analyzing `constant` and `static` declarations.

unsafe fn resolveConstOrStatic 'arena (

    matchBy: MatchBy

) throws (ResolveError) {

    match pattern.value {

        case ast::NodeValue::Call(call) => {

            // Unlabeled patterns: `S(x, y)`.

            for binding, i in call.args {

                let fieldType = recInfo.fields[i].fieldType;

                try bindPatternVar(self, binding, fieldType, matchBy);

            }

        }

        case ast::NodeValue::RecordLit(lit) => {

            // Labeled patterns: `T { x, y }` or `T { x: binding }`.

            if not lit.ignoreRest {

            }

            for fieldNode in lit.fields {

                let case ast::NodeValue::RecordLitField(field) = fieldNode.value

                    else panic "expected RecordLitField";