Type Checker implementation discussion

[shubhamnarlawar]

From the internal discussion we had -

To write a Rust function that does the typecast within the Rust object and returns us the pointer to the object of the new type. You need to check how typecast works in Rust. Then a typecast operation will simply be a call to that Rust function. There will be an additional check needed to see if the typecast is valid or not. That can be done using the same old smart pointer technique that we were doing earlier. Just that now the type will be a string with the array type and its size encoded in it. Do this typecheck using the mangled strings (like C++ names) representing the types. We can follow a convention like the mangled names start with a double underscore. Then the first letter denotes the base type. The following can be the schema for the first letter:

I - Int
C - Char
F - Float
S - String
R - Record
U - Union
B - Boolean
A - Array
J - JSON

Now for an array, the A will be followed by the type of the array, which will be again a letter from the above set. This will be followed by a 2 digit hex number representing the number of decimal digits to follow. These decimal digits will represent the size of the array. This will be followed by another two hex digits representing the number of characters to follow that represent the name of the array. So for example an array like:

int my_arr[1024];

will have a mangled name of:

AI04102406my_arr

Here the first letter A represents an array, the second letter I represents the type int, then the two hex digits 04 tell that the next 4 digits represent the size, so 1024 becomes the size. Then the two hex digits 06 say that the next 6 characters represent its name, viz., my_arr.

So a reference to this string has to be stored in the first/second element of the smart pointer, as needed.

Now with this, the type checker needs to do a string compare of two such type strings to determine if the type can be cast from one to the other or not. Based on the result of that call, the generated code should either call the type conversion Rust library or it should call something like an abort().

[shubhamnarlawar]

Also, apart from passing source and target type string, we need to pass original types for the typecase operation.

[ruvi-d]

would you mind sharing an example for what you mean by original types?

[shubhamnarlawar]

Consider below four types - A, B, F, G

A -> B //A is typecasted to B
F -> G //F is typecasted to G

B to G typecast is possible only if A to F can be type casted (possible only if source types of B and G are known i.e. A and F).

Original types here I meant was, if current source type that is to be type casteed to destination type had already undergone typecast or not?

[ruvi-d]

Understood what you meant by original types.
So is your modeling a variable/reference as consisting of : {type, data, original_type} ?

Considering the covariant behavior that Manu described as:

// ballerina arrays are covariant (unlike java)
    byte[] arr1 = [5, 24, 56, 243];
    int[] arr3 = arr1;
    io:println(arr3[2]); // prints 56
    arr1[2] = 4;
    io:println(arr3[2]); // prints 4
    arr3[1] = 10;
    io:println(arr1[1]); // prints 10
    // arr3[1] = 1000; //runtime error

I am wondering whether it the model should be some thing like this:
variable/reference : {type, value_struct}
value_struct : {original_type, data}

Basically bind the original type as a property of the underlying data so that we can easily handle things like the covariant behavior.

[Kishanthan]

How would the following example work with proposed type checking approach above?

Basically, how are we planning support the any type here?

any[] a = [1, 2.5, true, "hello"]; 

[shubhamnarlawar]

@Kishanthan - I will get back to you on this.

[ayonam]

Actually, the Any type should have a different letter.  Probably 'X'.  And the string comparator should match any character with X in that position.  So, e.g., any[20] a;   // AX022001a int[10] b;    // AI021001b Now we should be able to typecast array 'b' to array 'a' because the size of 'b' is smaller than size of 'a' and 'a' is of a wider type.  When we come to the comparator, when it sees the first difference in the string, it will be in the second character.  Since one of them is X, it will ignore the difference and move ahead.  Now the next difference is in the 5th character.  Here, it will see that the size typecast is from smaller to larger and hence it will ignore it.  The last difference is in the last character.  It will ignore that difference, since that is part of the name. BTW, the intelligent comparator as described above will be called only when the dumb comparator declares them to be different by doing a simple string compare.  So the case, where the types are trivially same, the dumb comparator itself will return a positive result. On 02/02/21 16:26, Kishanthan Thangarajah wrote: How would the following example work with proposed type checking approach above? Basically, how are we planning support the any type here? any[] a = [1, 2.5, true, "hello"]; — You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub, or unsubscribe. [ { "@context": "http://schema.org", "@type": "EmailMessage", "potentialAction": { "@type": "ViewAction", "target": "https://github.com/ballerina-platform/nballerina/discussions/50#discussioncomment-330479", "url": "https://github.com/ballerina-platform/nballerina/discussions/50#discussioncomment-330479", "name": "View Discussion" }, "description": "View this Discussion on GitHub", "publisher": { "@type": "Organization", "name": "GitHub", "url": "https://github.com" } } ]

[shubhamnarlawar]

@manuranga - In PR #43 you suggested to use blackbox approach i.e. pointer to rust String.

Currently, we are sending foo.to_str() which is NULL terminated string from C++ to Rust.

1. Convert pointer to string into CString/CStr
2. Convert CString/CStr into Rust string.
3. Use rust string operations to achieve the desired functionality. (achieved below).

My doubt is - Is it correct way to convert C++ string to CStr in rust and then convert it to simple rust string? I tried this approach but the final string obtained from above does not seems a simple rust string but a std::ffi::CString::into_string.......

Can you give your thoughts on this?

----------------------Rust code written so far--------------------------------------------

#[no_mangle]
pub extern "C" fn is_same_type(src_type: *mut c_char, dest_type: *mut c_char) -> bool
{
//Need to add conversion here to convert from null terminated string to Rust String.
let source = String::from("AB04102406my_arr");
let destination = String::from("AI04102406my_arr");
if source.chars().nth(0) != destination.chars().nth(0) {
return false;
}
let mut src_type_priority = 0;
let mut dest_type_priority = 0;
//Compare the data type sizes
if source.chars().nth(1) != destination.chars().nth(1) {
// Assign type priorities to source and destination type
match source.chars().nth(1)
{
Some('C') => src_type_priority = 4,
Some('B') => src_type_priority = 1,
Some('F') | Some('I') => src_type_priority = 8,
_ => println!("Unsupported type"),
}
match destination.chars().nth(1)
{
Some('C') => dest_type_priority = 4,
Some('B') => dest_type_priority = 1,
Some('F') | Some('I') => dest_type_priority = 8,
_ => println!("Unsupported type"),
}
}

//If source data type is bigger than destination then typecast is not possible
if src_type_priority > dest_type_priority
{
return false;
}

let mut src_bits = String::new();
src_bits.push(source.chars().nth(2).unwrap());
src_bits.push(source.chars().nth(3).unwrap());
let src_bits_int : i32 = src_bits.parse().unwrap();

let mut dest_bits = String::new();
dest_bits.push(destination.chars().nth(2).unwrap());
dest_bits.push(destination.chars().nth(3).unwrap());
let dest_bits_int : i32 = dest_bits.parse().unwrap();

//Total size of type starts at 4th index of a string
let index = 4;

// Fetch 4th and 5th index of string to get total size of source type.
let mut src_length = String::new();
for i in 0..src_bits_int {
let iterator = i as usize;
src_length.push(source.chars().nth(iterator + index).unwrap());
}

//Convert source type size from string to int.
let src_length_int:i32 = src_length.parse().unwrap();

let mut dest_length = String::new();
// Fetch 4th and 5th index of string to get total size of destination type.
for i in 0..dest_bits_int {
let iterator = i as usize;
dest_length.push(destination.chars().nth(iterator + index).unwrap());
}

//Convert destination type size from string to int.
let dest_length_int:i32 = dest_length.parse().unwrap();

//If source type size > destination type size then typecast is not possible
if src_length_int > dest_length_int {
return false;
}
//If all the conditions are met then, typecast from source to destination is possible
return true;
}

---

Edits -

1. Original types is yet to add in code which would be a simple if condition at the start of above algorithm.

[shubhamnarlawar]

@manuranga - In PR #43 you suggested to use blackbox approach i.e. pointer to rust String.

Currently, we are sending foo.to_str() which is NULL terminated string from C++ to Rust.

1. Convert pointer to string into CString/CStr

2. Convert CString/CStr into Rust string.

3. Use rust string operations to achieve the desired functionality. (achieved below).

My doubt is - Is it correct way to convert C++ string to CStr in rust and then convert it to simple rust string? I tried this approach but the final string obtained from above does not seems a simple rust string but a std::ffi::CString::into_string.......

Can you give your thoughts on this?

----------------------Rust code written so far--------------------------------------------

#[no_mangle]
pub extern "C" fn is_same_type(src_type: *mut c_char, dest_type: *mut c_char) -> bool
{
//Need to add conversion here to convert from null terminated string to Rust String.
let source = String::from("AB04102406my_arr");
let destination = String::from("AI04102406my_arr");
if source.chars().nth(0) != destination.chars().nth(0) {
return false;
}
let mut src_type_priority = 0;
let mut dest_type_priority = 0;
//Compare the data type sizes
if source.chars().nth(1) != destination.chars().nth(1) {
// Assign type priorities to source and destination type
match source.chars().nth(1)
{
Some('C') => src_type_priority = 4,
Some('B') => src_type_priority = 1,
Some('F') | Some('I') => src_type_priority = 8,
_ => println!("Unsupported type"),
}
match destination.chars().nth(1)
{
Some('C') => dest_type_priority = 4,
Some('B') => dest_type_priority = 1,
Some('F') | Some('I') => dest_type_priority = 8,
_ => println!("Unsupported type"),
}
}

//If source data type is bigger than destination then typecast is not possible
if src_type_priority > dest_type_priority
{
return false;
}

let mut src_bits = String::new();
src_bits.push(source.chars().nth(2).unwrap());
src_bits.push(source.chars().nth(3).unwrap());
let src_bits_int : i32 = src_bits.parse().unwrap();

let mut dest_bits = String::new();
dest_bits.push(destination.chars().nth(2).unwrap());
dest_bits.push(destination.chars().nth(3).unwrap());
let dest_bits_int : i32 = dest_bits.parse().unwrap();

//Total size of type starts at 4th index of a string
let index = 4;

// Fetch 4th and 5th index of string to get total size of source type.
let mut src_length = String::new();
for i in 0..src_bits_int {
let iterator = i as usize;
src_length.push(source.chars().nth(iterator + index).unwrap());
}

//Convert source type size from string to int.
let src_length_int:i32 = src_length.parse().unwrap();

let mut dest_length = String::new();
// Fetch 4th and 5th index of string to get total size of destination type.
for i in 0..dest_bits_int {
let iterator = i as usize;
dest_length.push(destination.chars().nth(iterator + index).unwrap());
}

//Convert destination type size from string to int.
let dest_length_int:i32 = dest_length.parse().unwrap();

//If source type size > destination type size then typecast is not possible
if src_length_int > dest_length_int {
return false;
}
//If all the conditions are met then, typecast from source to destination is possible
return true;
}

Edits -

1. Original types is yet to add in code which would be a simple if condition at the start of above algorithm.

I found a solution here to convert a C NULL terminated string to rust string -

1. Convert pointer pointing to null terminated string to &CStr.
2. Convert &CStr to &str
3. Convert &str to rust string

By this, I would be able to perform operations provided by rust string. I have found this only solution to my case. If anyone has better idea than this, please do share. I am open to change my current working algorithm.

let s: &CStr = unsafe { CStr::from_ptr(src_type) };
let ss: &str = s.to_str().unwrap();;
let source: String = ss.to_owned();

Now on this rust string named "source" - the entire algorithm works that lets us know whether type casting is possible or not.

[ruvi-d]

Discussion about this sub topic has been moved to Slack : https://ballerina-platform.slack.com/archives/C01LNSAHK18/p1612811412012200