Compiler does not always complain about type mismatch for returned values from functions

[m-fawaz]

Example:
We do not expect the following two functions to compile:

fn foo() -> u32 {
     let val:u64 = 0;     
     val
}

 fn foo() -> u64 {
      let val:u32 = 0;     
      val
 }

But the compiler does not give any compile errors.
However, the compiler does complain when bool is expected. E.g.

 fn foo() -> bool {
      let val:u32 = 0;     
      val
 }

Rust does not allow implicit conversions as shown in the first two functions. Sway should probably not allow that either.

[mohammadfawaz]

Another minor thing to fix here is to avoid emitting a warning in cases such as the following:

  let x:u32 = 1;

The compiler assumes that the type of 1 is u64 and so, we get the following warning:

This cast, from integer type of width sixty four to integer type of width thirty two, will lose precision

Rust does not complain about the pattern above. It only complains if the integer does not actually fit in the variable type. E.g.

  let x:u8 = 256; // 255 is fine.

leads to a compile error.