Implement parsing and typechecking of new cast operators

[dtarditi]

Section 5.1 of the Checked C specification describes new cast operators for converting between pointers with different kinds of checking. It also describes changes to the existing C cast operator for checked pointer types.

Here are the proposed work items for this feature:

• Design for extending IR with new cast information.
• Implement IR extension for dynamic_bounds_cast and parse dynamic_bounds_cast<T>(e1), dynamic_bounds_cast<T>(e1, e2) , and dynamic_bounds_cast<T>(e1, e2, e3).
• Same as above but for assume_bounds_cast.
• Implement type checking rules for C-style casts involving checked pointer types. Work includes writing tests.
• Implement type checking rules for dynamic_bounds_cast. Work includes writing tests.
• Implement type checking rules for assume_bounds_cast. Work includes writing tests.

[jijoongmoon]

I have some questions about dynamic and assume bounds cast in spec.
According to spec, it says " dynamic bounds cast(e1 ) converts e1 to either a ptr or *** type.**"
I wonder what might be the result after the dynamic bounds cast Done according to the e1. I thought the result of Dynamic/Assume bounds cast is Checked Type. But it says converts e1 to unchecked pointer type.
How can we handle these cases differently?
int *p;
ptr<int> q = 0;
ptr<int> r = 0;
r = assume_bounds_cast<int>(q);
p = assume_bounds_cast<int>(q);

[dtarditi]

The spec is unclear. The type argument should be the "full pointer type". In your example, it would be:

r = assume_bounds_cast<ptr<int>>(q);
p = assume_bounds_cast<int *>(q);`

This is the same way that the various C++-style cast operators work (they take the full target type).
It would be good to add some examples to the spec. The need to improve the description of the bounds cast operators is tracked by checkedc/checkedc#4.

[jijoongmoon]

1 : r = assume_bounds_cast<ptr<int>>(q);
2 : p = assume_bounds_cast<int *>(q);

so, in the case or 1, assume_bounds_cast should generate _Ptr<_Ptr> type, and in case of 2, assume_bounds_cast should generate _Ptr<int*>. Am I right?

int *p;
ptr<int> q = 0;
ptr<int> r = 0;
3: r = assume_bounds_cast<int>(q);
4 : p = assume_bounds_cast<int>(q);

And 3 is OK and 4 supposed to be Incompatible type error. In case of 3, assume bounds cast generate _Ptr type, and talking about 4, it also make _Ptr and try to assign unchecked variable. That's why it generates incompatible type error.

[dtarditi]

The type of assume_bounds_cast<T>(e) is T. So in case 1, it generates type _Ptr. In case 2, it generates an int *. There is no additional wrapping of the type.

From a typing perspective, it is similar to the static_cast(e) and dynamic_cast(e) C++ operators, which have type T. The Checked C operators are designed for casts of pointers with bounds.