Support 'new.target' meta object

[DanielRosenwasser]

There isn't a lot in the current ES6 spec draft, but it seems to indicate the constructor object that is in the process of being new'd at runtime.

[rbuckton]

We also need to update es6.d.ts for Reflect.construct which has the signature:

export function construct(target: any, argArray: any[], newTarget?: any): any;

Where newTarget is the value for new.target.

[mhegazy]

See relevant down-level emit suggestions in #8494

[kitsonk]

For completeness I will just copy them here:

Given:

function Foo() {
  console.log(new.target);
}

Foo(); // logs undefined
new Foo(); // logs Foo

The downlevel emit could be:

function Foo() {
  var _newTarget = this === (typeof window === 'undefined' ? global : window) ? undefined : this && this.constructor;
  console.log(_newTarget);
}

Foo(); // logs undefined
new Foo(); // logs Foo

When 'use strict'; is used, then this will be undefined anyways and the emit could simply be:

'use strict';

function Foo() {
  var _newTarget = this && this.constructor;
  console.log(_newTarget);
}

Foo();  // logs undefined
new Foo(); // logs Foo

[ghost]

Just happened across this thread while looking at TS support for 'new.target'.

For use case of importing a function such as the Foo example above when such function is exported from, say, a CommonJS module, the immediately preceding comment re "When 'use strict'; is used, then 'this' will be undefined anyways and the emit could simply be ..." is not valid under all circumstances.

It is only valid in the use case whence Foo is invoked as a top-level function (either via new or normal function call) in the same source file.

When otherwise invoked as an imported function/constructor combo, it depends on whether the reference to Foo is obtained from a top-level variable (case 1) or via an import member in which case the reference is possibly, depending on codegen, obtained by a property access (case 2), i.e.

import { Foo } from "foo";

// case 1:
const Foo = foo.Foo;
Foo();
new Foo();

// case 2:
foo.Foo();
new foo.Foo();

For the moment, I'm going with this method in my code albeit correct though not completely generic (since have to type === functionname).

"use strict";
function Foo() {
  // simulate if (!new.target) with following line ...
  if (!this || this.constructor !== Foo) {
    console.log("Foo called without new");
  }

  else {
    console.log("Foo instantiated with new");
  }
}

exports.Foo = Foo;