destructors moved out of place ?

I have a question whether compiler can move destructors past
the place when it's normal out-of-scope place is. Is this true ?
Example:
I have a lock/unlock wrapped into the object SafeLock,

     where   SafeLock::SafeLock() { m_lock.Lock(); }
     and      SafeLock::~SafeLock() { m_lock.Unlock(); }
     void Class::Method(void) {
          SafeLock lock; // lock in ctor, unlocks in dtor
          ......
          // (1) lock is automatically unlocked here, ok.
     }

So far, so good. The lock is unlocked at point (1), when it goes out
of scope.

Now let's look at the more complex case, with innner block:

      void Class::Method(void) {
         ......
         { // inner block
                SafeLock lock; // (4)
         } // (5)
         ... // (6)
      }

Normally, lock(4) is destroyed at (5).

But I was told this is not necessarily so;
that C++ compiler is free to delay destruction of  lock
until later, until end of bigger bklock at (6).

Is this true ? Is it indeed allowd ? I have difficulty to believe
that
standard allows this. Indeed, destructors can have side effects like
closing files.

Is it possible to have standard reference that explicitly
prohibits this "optimization" ?

Viki