Extending the unsafe keyword

[tczajka]

@josh

It's hard to distinguish the bounds of how far unsafe goes without braces. If you write unsafe a.b.c().d(), is that unsafe { a.b }.c().d() or unsafe { a.b.c() }.d() or unsafe {a.b.c().d() }? If you write unsafe e1 + e2 is that unsafe { e1 } + e2 or unsafe { e1 + e2 }?

If we were to introduce something like that, we'd need a rule for how far it extends, and that seems more complex and less immediately obvious than requiring the braces.

I have in the past proposed that the unsafe keyword only applies to a single function call, and method calls use a different syntax:

Ability to call unsafe functions without curly brackets

How about this syntax? let a = foo().unsafe bar(baz()).xyz(); // unsafe only applies to bar let a = unsafe foo(bar()); // unsafe only applies to foo, not bar I think this works well because it's maximally conservative. If somebody gets confused and thinks bar would also be marked unsafe in the second example, they will just get a compile error.

So you would write your example as a.b.unsafe c().d().

This wouldn't work with operators, only function calls and method calls.

In unsafe f(g()).h() it would only apply to f, not g or h. Note that there is currently no way to write this without introducing an extra variable or unnecessarily including g() in the unsafe block.

If anybody mistakenly writes it thinking it applies to more than the f call there will be no great harm done: they will just get a compile error.

@josh

Personally, the way I'd love to write the function you started the thread with is:

unsafe fn map_physical_region<T>(&self, physical_address: usize, size: usize) -> PhysicalMapping<Self, T>
unsafe {
    PhysicalMapping::new(
        physical_address,
        self.as_ptr(physical_address),
        size,
        size,
        *self,
    )
}

In this example, assuming self.as_ptr is a safe function, it is unnecessarily included in the unsafe block. So there is more to analyze regarding safety than if the unsafe keyword only applied to the function call.