Understanding Rust Error E0699

Introduction to Rust Error E0699

Rust Error E0699 occurs when a method is called on a raw pointer whose inner type is not completely known. This can happen when the type of a raw pointer is not explicitly specified, leading to potential ambiguity in the code. In this article, we will explore the root cause and solution to Rust Error E0699 using code examples.

Erroneous Code Example

#![deny(warnings)]
fn main() {
let foo = &1;
let bar = foo as *const _;
if bar.is_null() {
    // ...
}
}

In the erroneous code example above, we see that the type of 'bar' is not specified, causing Rust Error E0699. To fix the issue, we must explicitly specify the type of the pointer.

Solution to Rust Error E0699

To solve Rust Error E0699, provide a clear type for the pointer. Preferably, use a type that matches the data you're pointing to. Here's the updated code:

#![allow(unused)]
fn main() {
let foo = &1;
let bar = foo as *const i32;
if bar.is_null() {
    // ...
}
}

In this fixed code example, we have specified the type of the pointer as 'i32', which eliminates the ambiguity and resolves Rust Error E0699.

Background: Arbitrary Self Types

The reason why Rust shows Error E0699 is because Rust allows 'self' to have arbitrary types behind the 'arbitrary_self_types' feature flag. This opens up potential ambiguity when calling methods on raw pointers with unknown types.

For instance, someone can define a function like this:

impl Foo {
    fn is_null(self: *const Self) -> bool {
        // do something else
    }
}

Now, if you call '.is_null()' on a raw pointer to 'Foo', there's ambiguity. Since we don't know the type of the pointer and there's potential ambiguity for different types, Rust disallows calling methods on raw pointers with unknown types, which results in Error E0699.