Intl.[ctor] called with unusual target produces strange behavior

[dilijev]

Found by reading code and wondering "what does this button do?"

Apparently Intl.* constructors do not actually have to be called with new, and can be called with anything as the target.

Using Intl or undefined as the target (first param of call) produces the same result as calling new.
Specifically allowing the target to be Intl or undefined (see Intl.js code, snippet below) allows for calling as Intl.NumberFormat and assigning the same to a var and then calling, producing the same results.

// function NumberFormat
if (this === Intl || this === undefined) {
    // after the call to the same function using new, this === NumberFormat, but any other value of this will be allowed past this check, leading to strange behavior
    return new NumberFormat(locales, options);
}

## Source
let options = {style:'currency', currency:'USD'};
print(new Intl.NumberFormat('en-us', options).format(42));
print(Intl.NumberFormat.call(Intl, 'en-us', options).format(42));
print(Intl.NumberFormat.call(undefined, 'en-us', options).format(42));

print(Intl.NumberFormat('en-us', options).format(42)); /* call(Intl, ...) */
nf = Intl.NumberFormat;
print(nf('en-us', options).format(42)); /* call(undefined, ...) */

┌──────────────────┬────────┐
│ ch-1.7.1         │ $42.00 │
│ ch-master-latest │ $42.00 │
│ d8               │ $42.00 │
│ jsc              │ $42.00 │
│ node             │ $42.00 │
│ node-ch          │        │
│ sm               │        │
└──────────────────┴────────┘

Using anything else apparently returns the object passed in:

## Source
let options = {style:'currency', currency:'USD'};
let a = Intl.NumberFormat.call({}, 'en-us', options);
print(a);
print(a.format(42));

┌──────────────────┬───────────────────────────────────────────────────────────────┐
│ d8               │ [object Object]                                               │
│ jsc              │ $42.00                                                        │
│ sm               │                                                               │
├──────────────────┼───────────────────────────────────────────────────────────────┤
│ ch-1.7.1         │ [object Object]                                               │
│ ch-master-latest │ TypeError: Object doesn't support property or method 'format' │
├──────────────────┼───────────────────────────────────────────────────────────────┤
│ node-ch          │ {}                                                            │
│                  │ TypeError: Object doesn't support property or method 'format' │
├──────────────────┼───────────────────────────────────────────────────────────────┤
│ node             │ NumberFormat {}                                               │
│                  │ $42.00                                                        │
└──────────────────┴───────────────────────────────────────────────────────────────┘

## Source
let options = {style:'currency', currency:'USD'};
let a = Intl.NumberFormat.call(function foo() {}, 'en-us', options);
print(a);
print(a.format(42));

┌──────────────────┬───────────────────────────────────────────────────────────────┐
│ d8               │ [object Object]                                               │
│ jsc              │ $42.00                                                        │
│ sm               │                                                               │
├──────────────────┼───────────────────────────────────────────────────────────────┤
│ ch-1.7.1         │ function foo() {}                                             │
│ ch-master-latest │ TypeError: Object doesn't support property or method 'format' │
├──────────────────┼───────────────────────────────────────────────────────────────┤
│ node-ch          │ [Function: foo]                                               │
│                  │ TypeError: Object doesn't support property or method 'format' │
├──────────────────┼───────────────────────────────────────────────────────────────┤
│ node             │ NumberFormat {}                                               │
│                  │ $42.00                                                        │
└──────────────────┴───────────────────────────────────────────────────────────────┘

## Source
let options = {style:'currency', currency:'USD'};
let a = Intl.NumberFormat.call(new (function foo() {}), 'en-us', options);
print(a);
print(a.format(42));

┌──────────────────┬───────────────────────────────────────────────────────────────┐
│ d8               │ [object Object]                                               │
│ jsc              │ $42.00                                                        │
│ sm               │                                                               │
├──────────────────┼───────────────────────────────────────────────────────────────┤
│ ch-1.7.1         │ [object Object]                                               │
│ ch-master-latest │ TypeError: Object doesn't support property or method 'format' │
├──────────────────┼───────────────────────────────────────────────────────────────┤
│ node-ch          │ foo {}                                                        │
│                  │ TypeError: Object doesn't support property or method 'format' │
├──────────────────┼───────────────────────────────────────────────────────────────┤
│ node             │ NumberFormat {}                                               │
│                  │ $42.00                                                        │
└──────────────────┴───────────────────────────────────────────────────────────────┘

Which leads to fun things like formatting a Date with something you would have hoped was a NumberFormat object

## Source
let a = Intl.NumberFormat.call(Intl.DateTimeFormat, 'en-us', { style: 'percent' });
print(a);
print((a.format || (new a).format)(new Date(2017,0,1)));


┌──────────────────┬────────────────────────────────────────────────────────────────────────┐
│ d8               │ [object Object]                                                        │
│ jsc              │ 148,325,760,000,000%                                                   │
│ sm               │                                                                        │
├──────────────────┼────────────────────────────────────────────────────────────────────────┤
│ ch-1.7.1         │ function DateTimeFormat() { [native code] }                            │
│ ch-master-latest │ ?1?/?1?/?2017                                                          │
├──────────────────┼────────────────────────────────────────────────────────────────────────┤
│ node-ch          │ { [Function: DateTimeFormat] __relevantExtensionKeys: [ 'ca', 'nu' ] } │
│                  │ ‎1‎/‎1‎/‎2017                                                          │
├──────────────────┼────────────────────────────────────────────────────────────────────────┤
│ node             │ NumberFormat {}                                                        │
│                  │ 148,325,760,000,000%                                                   │
└──────────────────┴────────────────────────────────────────────────────────────────────────┘

[dilijev]

@bterlson I'm sure that our behavior here is simply incorrect, but I want to make sure we get all the nuances of the behavior in the fix for this. I'm having a hard time reading through the relevant spec to see what all the cases would be. https://tc39.github.io/ecma402/#sec-intl-numberformat-constructor

[bterlson]

@dilijev what cases are you referring to? How can I help?

[dilijev]

@bterlson basically the Intl.js code in this case doesn't read very much like the spec. Might need a 1:1 with you to go over terminology and walk through the code. This can wait since it's Backlog for now.

It might not be relevant here but I get kind of lost when I start seeing ReturnIfAbrupt notations.

Having difficulty with this line;

1. If NewTarget is undefined, let newTarget be the active function object, else let newTarget be NewTarget.

That almost makes it sound like what we do in this case is some semblance of correct (maybe a little off) and that the other engines are wrong too, but I feel like that can't be right because the behavior makes no sense.

[jackhorton]

I have wondered about our behavior here too... I am almost sure its wrong, but its not entirely clear how to be right from reading the spec.