{"id":218,"date":"2013-02-03T16:56:18","date_gmt":"2013-02-03T16:56:18","guid":{"rendered":"http:\/\/bryants.eu:7564\/blog\/?p=218"},"modified":"2013-02-03T16:59:53","modified_gmt":"2013-02-03T16:59:53","slug":"casting-and-instanceof","status":"publish","type":"post","link":"https:\/\/bryants.eu\/blog\/2013\/02\/casting-and-instanceof\/","title":{"rendered":"Casting and Instanceof"},"content":{"rendered":"

Last week, I implemented the instanceof<\/code> operator. Doing this made me consider in much more detail how casting and instanceof should work, as there are several ways that they could.<\/p>\n

The Unified Type System<\/h2>\n

A unified type system is one where every type can be cast to some all-encompassing super-type. In Plinth, the name of that type is ‘object<\/code>‘, or to be more specific ‘?#object<\/code>‘ in order to account for nullability and immutability.<\/p>\n

When you cast, say, a double<\/code> to an object<\/code>, you are implicitly performing a heap allocation so that the double<\/code> can be stored on the heap inside something that looks like an object<\/code>. In fact, it is just an object<\/code> with a double<\/code> tacked onto the end, and with its virtual functions replaced by ones which extract that double<\/code> and call the real functions. The same system is used to cast tuples, compounds, functions, and all of the other primitives to objects.<\/p>\n

On the other hand, arrays and classes already look enough like objects to be cast to them directly (using the same pointer).<\/p>\n

Because we might want to use instanceof<\/code> on an object<\/code>, or check whether to throw a CastError<\/code> before we actually do a cast, every object stores a pointer to a block of run-time type information (RTTI). This RTTI holds data about the sort of type (e.g. ‘primitive’ or ‘array’), and the properties of the individual type (e.g. the kind of primitive it is, or\u00a0an array’s base type). When we cast a double<\/code> to an object<\/code>, that object<\/code> has an RTTI block for double<\/code>.<\/p>\n

Casting<\/h2>\n

Different casts are performed in very different ways. A cast from uint<\/code> to long<\/code> simply zero-extends the binary value from 32 bits to 64 bits, whereas a cast from a class Foo<\/code> to object<\/code> is just a matter of reinterpreting the same pointer as a different type.<\/p>\n

Casting from an object<\/code> to some other type is much more complicated. If the RTTI for the object does not match the destination type properly, we need to throw a CastError<\/code>. If it does match, we might have to extract a value from inside the object, or maybe reinterpret that object as a class, or possibly search through the RTTI for a super-interface’s VFT and tuple it with the object pointer.<\/p>\n

But what happens if we do the following:<\/p>\n

long a = 5;\r\nobject obj = a;\r\nint b = cast<int> obj;<\/pre>\n
The object<\/code> is a long<\/code>, but long<\/code>s can be cast to int<\/code>s easily – they are just a truncation from 64 bits to 32 bits.<\/p>\n
The problem is knowing that obj<\/code> is a long<\/code>. It might be anything from a boolean<\/code> to a string<\/code>, in which cases the result should definitely be a CastError<\/code>. Since the RTTI for long<\/code> doesn’t match the values we expect for an int<\/code>, the cast won’t be allowed.<\/p>\n
However, with a lot of work, it would be possible to allow it. We could write a really long line of checks for whether the run-time-type is int<\/code> or ubyte<\/code> or boolean<\/code> or float<\/code> or {uint -> string}<\/code> or [][]double<\/code>. We would actually only need to check the types that we could convert from, but it would require a huge amount of LLVM code for such a small amount of Plinth code.<\/p>\n
This type of “transitive” cast gets especially cumbersome when you consider the fact that you can convert tuples like (ubyte, short, boolean)<\/code> to (int, long, boolean)<\/code>. If this type of cast were allowed, casting from an object to a tuple would require looking through the RTTI for each of the tuple’s values (recursively) to first check whether the conversion is possible, and second find out how to perform it.<\/p>\n
In Plinth, transitive casts are not allowed. In order to handle the sort of cast we tried to do above, we would have to do something like:<\/p>\n
int b = cast<int> cast<long> obj;<\/pre>\n
Instanceof<\/h2>\n
The instanceof operator (which might be renamed to ‘is<\/code>‘ at some point) allows you to check whether a value is an instance of a given type. For example:<\/p>\n
long a = 5;\r\nobject obj = a;\r\nboolean isInt = obj instanceof int; \/\/ false\r\nboolean isFoo = obj instanceof ?#Foo; \/\/ type error: cannot check against a nullable or immutable type<\/pre>\n
As shown, you cannot check whether something is nullable or data-immutable. This is because these are properties of the reference, not the value itself: even if the reference is immutable,\u00a0the value behind the reference usually won’t be. Similarly, the value behind a nullable field won’t itself be nullable – it can’t be null. The exception to this is when checking nested types: []boolean<\/code> is different from []?boolean<\/code>.<\/p>\n
There are several different ways which instanceof<\/code> could have worked. For example it could return true whenever the value is assignable to the type without losing data, so a uint<\/code> with value 3<\/code> would be an instance of ubyte<\/code>, because it fits inside an 8 bit unsigned value. This scheme would have required the same sort of transitive checking described above.<\/p>\n
Another way would have been to return true whenever the assignment would work in a single step without losing data (i.e. the same, but without the transitive checks), which would illustrate exactly when casting would work. This could give you true for (ubyte, Foo, string) instanceof (uint, Bar, string)<\/code>. It could even allow nullable values, returning true if a null value were checked against a nullable type. The problem is that this system is very often confusing and can’t tell you unambiguously whether this number you’ve got is a ubyte<\/code>.<\/p>\n
Plinth uses the simplest and hopefully the most obvious system: value instanceof type<\/code> is only true when the value is already an instance of type. For classes and interfaces, this means checking against all super-types as well, because those super-types are part of the sub-type. But comparing a short<\/code> to an int<\/code> will result in false even if the cast is known at compile time to be just a sign-extension to 32 bits.<\/p>\n","protected":false},"excerpt":{"rendered":"
Last week, I implemented the instanceof operator. Doing this made me consider in much more detail how casting and instanceof should work, as there are several ways that they could. The Unified Type System A unified type system is one where every type can be cast to some all-encompassing super-type. In Plinth, the name of […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3],"tags":[],"_links":{"self":[{"href":"https:\/\/bryants.eu\/blog\/wp-json\/wp\/v2\/posts\/218"}],"collection":[{"href":"https:\/\/bryants.eu\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/bryants.eu\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/bryants.eu\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/bryants.eu\/blog\/wp-json\/wp\/v2\/comments?post=218"}],"version-history":[{"count":8,"href":"https:\/\/bryants.eu\/blog\/wp-json\/wp\/v2\/posts\/218\/revisions"}],"predecessor-version":[{"id":225,"href":"https:\/\/bryants.eu\/blog\/wp-json\/wp\/v2\/posts\/218\/revisions\/225"}],"wp:attachment":[{"href":"https:\/\/bryants.eu\/blog\/wp-json\/wp\/v2\/media?parent=218"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/bryants.eu\/blog\/wp-json\/wp\/v2\/categories?post=218"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/bryants.eu\/blog\/wp-json\/wp\/v2\/tags?post=218"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}