Enable default properties

[zspitz]

No description provided.

[zspitz]

Default properties cannot be used in Javascript, because there is no Set/Let distinction. The only possibility would be via some AST transformation.

[zspitz]

Automation objects have the concept of a default property -- a property that is accessed without actually calling the name of the property. When the property has parameters:

interface Dictionary<TKey = any, TItem = any> {
    Item(Key: TKey): TItem;
}

then it can be used from Javascript:

const dict: Dictionary<string, number> = new ActiveXObject('Scripting.Dictionary');
dict.Add('A', 1);
WScript.Echo(dict('A'));

and can be typed on an interface using a callable signature:

interface Dictionary<TKey = any, TItem = any> {
    Item(Key: TKey): TItem;
    (Key: TKey): TItem;
}

Conclusion: default properties with parameters can be modeled in definition files.

---

• What happens when the default property has no parameters? There is an ambiguity:

// Person object has Name as default property
var person = new ActiveXObject('Person');
// will person contain the new instance of Person, or will it contain the value of the Name property?

---

Only interfaces can have callable signatures; classes cannot currently have them.

Currently we are using classes for Automation types, in order to use private members to prevent newing the type or assigning plain Javascript objects with a matching shape. So we cannot model default properties in this case.

However, the benefits of default properties outweigh the benefits of typing as a class, so when there is a default property we should type as interface with the default property.

---

In order to resolve this fully, one of three things could happen:

• Interfaces would allow private members -- then we could use interfaces with their call signature for default properties, and a private member to enforce nominal typing
• Interfaces would allow enforcing nominal typing directly; same as above, but no private member required
• Classes would allow a callable signature

[zspitz]

There is a further issue: adding callable signatures means Typescript defines the interface as a function, with all a function's methods -- call, apply, constructor etc.