Destructor call order

[AngryLawyer]

struct Outer {
    inner: Inner
}

impl Outer : Drop {
    fn finalize(&self) {
        io::println("Outer has been dropped");
    }
}

struct Inner {
    dummy: bool
}

impl Inner : Drop {
    fn finalize(&self) {
        io::println("Inner has been dropped");
    }
}

fn main() {
    let outer = Outer{
        inner: Inner{
            dummy: true
        }
    };

I'd have expected the output to be as so

Inner has been dropped
Outer has been dropped

But we get

Outer has been dropped
Inner has been dropped

Is this correct? There are cases when you're interfacing with external libs where stuff needs to be created in one order, and then destroyed in reverse, such as with SDL creating and releasing a surface should only happen in between Init and Exit commands. The way it currently stands means the outermost object gets its destructor called first, which means bad things happen.

Am I missing the correct way to do this?

[catamorphism]

I would hazard a guess that when the Rust compiler translates this code, it generates a cleanup for outer first, then for inner, so outer's destructor runs first. I'm not sure what guarantees we make in our (hypothetical) semantics about destructor order. You could probably get the right behavior by naming the Inner struct and declaring it first. However, we should document the semantics more clearly.

[nikomatsakis]

I'm pretty sure that destructors SHOULD run outside-in. Otherwise the outer object would have access to the inner object after its destructor had executed, which is not how things are supposed to work.

[nikomatsakis]

Just for reference, this C++ program:

#include <stdio.h>

class Inner {
  public:
  ~Inner() { printf("Inner\n"); }
};

class Outer {
  public:
  Inner c;
  ~Outer() { printf("Outer\n"); }
};

int main() {
  Outer outer;
  return 0;
}

prints outer then inner, just as Rust does.

[AngryLawyer]

Argh, I feel silly, the order seems obvious now! Thanks for clarifying thing, folks.