JS: Add a new "undefined" type (or proxy it as "void")?

[matanlurey]

Would supercede #24088.

In JavaScript some APIs have a distinction between undefined and null, i.e. they do:

function storeVar(name, value) {
  if (value == undefined) {
    value = _someDefault;
  }
}

This isn't terribly different from how we treat optional parameters today, i.e. the call site determines if it uses the default expression, if any, otherwise it is null. Unfortunately we lack the way to:

1. Access the undefined JS type (for JS-interop) - see Need a way of passing undefined to JS via dart:js #24088.
2. Use the undefined type ourselves as a type of (pun intended) sentinel value.

The second use case is extra interesting, because some JavaScript VM's can understand that null and undefined are sentinel-like values, but they can't tell that some arbitrary Dart object is (believing it is polymorphic) - but more importantly, because we'd like to retain type inference and types wherever possible.

final _notFoundSentinel = new Object();

abstract class DynamicInjector {
  dynamic get(Type token) {
    var result = _getImpl(token, _notFoundSentinel);
    if (identical(result, _notFoundSentinel)) {
      throw 'Not found';
    }
    return result;
  }

  dynamic _getImpl(Object token, Object defaultIfNotFound);
}

This works, OK (minus potential perf consequences of using an arbitrary object), but notice that I am forced to use a dynamic type for practically everything. In Dart 2, I might be able to "tighten" this up a bit:

final _notFoundSentinel = new Object();

abstract class DynamicInjector {
  T get<T>() {
    assert(T != dynamic, 'Type parameter T, which is the token, is required!');
    // Runtime error: _notFoundSentinel (Object) is not of type T (SomeClass)
    var result = _getImpl(token, _notFoundSentinel);
    if (identical(result, _notFoundSentinel)) {
      throw 'Not found';
    }
    return result;
  }

  Object _getImpl(Object token, Object defaultIfNotFound);
}

If I had an undefined type (or could use void for this purpose):

import 'package:js/js.dart' as js show undefined;

const _notFoundSentinel = js.undefined;

abstract class DynamicInjector {
  T get<T>() {
    assert(T != dynamic, 'Type parameter T, which is the token, is required!');
    // No runtime error, "undefined" is allowed for any type.
    var result = _getImpl(token, _notFoundSentinel);
    if (identical(result, _notFoundSentinel)) {
      throw 'Not found';
    }
    return result;
  }

  Object _getImpl(Object token, Object defaultIfNotFound);
}

It gets a little tricky with non-nullability, but again, when you're dealing with JS APIs you don't have the luxury of pretending everything is 100% Dart. This would be no less "bad" than writing the following code yourself:

final dynamic undefined = js.eval('void 0');

// Use undefined.
void someInteropFunction(JsChartLib chart, [String name]) {
  chart.name = name ?? undefined;
}

[rakudrama]

One of the reasons dart2js and DDC treat both JavaScript null and JavaScript undefined as Dart null is so that Lists (Arrays) do not have to be explicitly null-filled. new List(10) can compile to new Array(10).

There are two values that are Dart null, just like there might be two Strings with value "a".
As a consequence, identical(js.null, js.undefined) --> true.
You would need another predicate to test for the value in Dart code.

If you want undefined to not be considered as Dart null, but be another null-like value that does not force you to use dynamic/Object, that would be a major change to the type system.

[matanlurey]

I mean we can be (clever?) here, most of the time (99%) you don't care.

I'd be fine if it "seemed" like null to Dart2JS/DDC, but there was a way of telling what it is:

library js;

external bool isUndefined(Null nullOrUndefined);

Example use:

import 'package:js/js.dart' as js;

void callWithArg(dynamic arg) {
  if (arg == null) {
    if (js.isUndefined(arg)) {
      // This is actually, at runtime, `undefined`, not `null`.
    } else {
      // This is actually, at runtime, `null`.
    }
  }
}

Would that be OK? I'd still need a way to assign undefined:

library js;

/// Returns the JS "undefined" type, i.e. equivalent to `void 0`.
external Null get undefined;

import 'package:js/js.dart' as js;

void useJsInterop(ChartJs chart) {
  chart.someApi(js.undefined);
}

[mdebbar]

Adding insult to the injury here regarding @rakudrama's comment, new Array(10) in JS creates an array that has 10 "holes" not "undefined".

let a = new Array(10);

a.forEach((x) => {
  console.log('foo');
});

for (let i = 0; i < a.length; i++) {
  console.log('bar');
}

The above code prints "bar" 10 times but no "foo". The forEach callback (and map and filter) are only called on concrete values in the array, but holes are not, so they are skipped.