null safety and map.exists

[ibilon]

Null safety isn't aware of map.exists which leads to warnings:

Main.hx

class Main {
	static function main() {
		var m = [1 => 2, 5 => 3];

		for (c in 0...10) {
			if (m.exists(c))
			{
				m[c]++;
			}
			else
			{
				m[c] = 0;
			}

			trace(m[c]);
		}
	}
}

build.hxml

-main Main
--interp
--macro nullSafety("Main", Strict)

Result

Main.hx:8: characters 5-11 : Null safety: Cannot assign nullable value here.
Main.hx:8: characters 5-11 : Null safety: Cannot perform binary operation on nullable value.
Main.hx:15: characters 10-14 : Null safety: Cannot pass nullable value to not-nullable argument "v" of function "trace".

Displayed 10 times (is the loop unrolled?)

Also we might want to make trace take a Null since trace(null); works fine.

[RealyUniqueName]

It's safe only in a single-threaded environment until there are no calls in between.

function handleMap(key:String, map:Map<String,String>):String {
  if(map.exists(key)) {
    doSomething();  //modifies map  
    return map[key]; // null goes into the wild
  }
  return 'default';
}

So allowing it makes sense only in Loose null-safety mode.
Also, there might be more types like this (at least all Haxe collections in std) and even in user-land code.
So instead of adjusting the compiler to a never-ending source of edge cases, I'd like to have a simple way for users to avoid null safety error.
E.g. with static extensions:

using Safety;

if(map.exists(key)) {
  doSomething();    
  return map[key].sure(); // returns a value or throws NPE right here if value is null
  //or if performance hit of an additional `if` statement metters more than safety:
  return map[key].unsafe(); // returns a value no matter what
}

This way we stay as safe as possible, satisfy the null checker if we don't want to stay safe at compile time, and get early error reporting at runtime.

[back2dos]

For strict safety, do this:

class Main {
  static function main() {
    var m = [1 => 2, 5 => 3];

    for (c in 0...10) 
      m[c] = switch m[c] {
        case null: 0;
        case v: v + 1;
      }
  }
}

Also, if performance matters, this should be faster, because it only does get instead of exists + get.

[Simn]

I don't know how I feel about hard-coding map-semantics into the compiler. There should be a more elegant solution to this problem...

On the other hand, an inelegant solution is still better than no solution.

[RblSb]

Found that in Strict/Loose mode:

if (null && null) // works
if (null) // error, works with `== true`

Is this a bug?
Also, maybe this case should works fine with Loose?

var map:Map<Int, Bool> = [1 => true];
if (map[1]) trace("error");

http://try-haxe.mrcdk.com/#0E661

[RealyUniqueName]

Is this a bug?

Yes

Also, maybe this case should works fine with Loose?

Yeah, since field access works in Loose mode I don't see a reason for array access to not work in the same situation.