emit as helper with runtime type check

Signed-off-by: Ashley Claymore <acutmore@users.noreply.github.com>

Author: acutmore

src/compiler/factory/emitHelpers.ts

@@ -34,6 +34,7 @@ namespace ts {
         // Class Fields Helpers
         createClassPrivateFieldGetHelper(receiver: Expression, privateField: Identifier): Expression;
         createClassPrivateFieldSetHelper(receiver: Expression, privateField: Identifier, value: Expression): Expression;
+        createClassPrivateFieldInHelper(receiver: Expression, privateField: Identifier): Expression;
     }
 
     export function createEmitHelperFactory(context: TransformationContext): EmitHelperFactory {
@@ -72,6 +73,7 @@ namespace ts {
             // Class Fields Helpers
             createClassPrivateFieldGetHelper,
             createClassPrivateFieldSetHelper,
+            createClassPrivateFieldInHelper
         };
 
         /**
@@ -377,6 +379,12 @@ namespace ts {
             context.requestEmitHelper(classPrivateFieldSetHelper);
             return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldSet"), /*typeArguments*/ undefined, [receiver, privateField, value]);
         }
+
+        function createClassPrivateFieldInHelper(receiver: Expression, privateField: Identifier) {
+            // TODO(aclaymore): will need to change emit for static private fields
+            context.requestEmitHelper(classPrivateFieldInHelper);
+            return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldIn"), /* typeArguments*/ undefined, [receiver, privateField]);
+        }
     }
 
     /* @internal */
@@ -844,6 +852,19 @@ namespace ts {
             };`
     };
 
+    export const classPrivateFieldInHelper: UnscopedEmitHelper = {
+        name: "typescript:classPrivateFieldIn",
+        importName: "__classPrivateFieldIn",
+        scoped: false,
+        text: `
+            var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(receiver, privateMap) {
+                if (receiver === null || (typeof receiver !== 'object' && typeof receiver !== 'function')) {
+                    throw new TypeError("Cannot use 'in' operator on non-object");
+                }
+                return privateMap.has(receiver);
+            };`
+    };
+
     let allUnscopedEmitHelpers: ReadonlyESMap<string, UnscopedEmitHelper> | undefined;
 
     export function getAllUnscopedEmitHelpers() {
@@ -869,6 +890,7 @@ namespace ts {
             exportStarHelper,
             classPrivateFieldGetHelper,
             classPrivateFieldSetHelper,
+            classPrivateFieldInHelper,
             createBindingHelper,
             setModuleDefaultHelper
         ], helper => helper.name));
@@ -897,4 +919,4 @@ namespace ts {
             && (getEmitFlags(firstSegment.expression) & EmitFlags.HelperName)
             && firstSegment.expression.escapedText === helperName;
     }
-}
+}

src/compiler/transformers/classFields.ts

@@ -146,18 +146,8 @@ namespace ts {
             if (info) {
                 const receiver = visitNode(node.expression, visitor, isExpression);
 
-                // TODO(aclaymore): will need to change emit for static private fields
-
-                // TODO(aclaymore): Should this be abstracted into a factory function?
                 return setOriginalNode(
-                    factory.createCallExpression(
-                        factory.createPropertyAccessExpression(
-                            info.weakMapName,
-                            "has"
-                        ),
-                        /* typeArguments: */ undefined,
-                        [receiver]
-                    ),
+                    context.getEmitHelperFactory().createClassPrivateFieldInHelper(receiver, info.weakMapName),
                     node
                 );
             }

tests/baselines/reference/privateNameInInExpressionTransform.errors.txt

@@ -1,16 +1,18 @@
 tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts(15,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.
 tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts(15,21): error TS2361: The right-hand side of an 'in' expression must not be a primitive.
 tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts(17,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.
-tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts(33,12): error TS18016: Private identifiers are not allowed outside class bodies.
+tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts(24,21): error TS1005: ';' expected.
+tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts(25,18): error TS1005: ';' expected.
+tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts(37,12): error TS18016: Private identifiers are not allowed outside class bodies.
 
 
-==== tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts (4 errors) ====
+==== tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts (6 errors) ====
     // TODO(aclaymore) add cases for static fields
 
     class Foo {
         #p1 = 1;
         check(v: any) {
-            #p1 in v; // expect `_p1.has(v)`
+            #p1 in v; // expect WeakMap '_p1'
         }
         precedence(v: any) {
             // '==' has lower precedence than 'in'
@@ -33,17 +35,25 @@ tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTr
 
             #p1 in v && #p1 in v; // Good precedence: ((#p1 in v) && (#p1 in v))
         }
+        invalidLHS(v: any) {
+            'prop' in v = 10;
+                        ~
+!!! error TS1005: ';' expected.
+            #p1 in v = 10;
+                     ~
+!!! error TS1005: ';' expected.
+        }
     }
 
     class Bar {
         #p1 = 1;
         check(v: any) {
-            #p1 in v; // expect `_p1_1.has(v)`
+            #p1 in v; // expect WeakMap '_p1_1'
         }
     }
 
-    function error(v: Foo) {
-        return #p1 in v; // expect `in v`
+    function syntaxError(v: Foo) {
+        return #p1 in v; // expect `return in v` so runtime will have a syntax error
                ~~~
 !!! error TS18016: Private identifiers are not allowed outside class bodies.
     }

tests/baselines/reference/privateNameInInExpressionTransform.js

@@ -4,7 +4,7 @@
 class Foo {
     #p1 = 1;
     check(v: any) {
-        #p1 in v; // expect `_p1.has(v)`
+        #p1 in v; // expect WeakMap '_p1'
     }
     precedence(v: any) {
         // '==' has lower precedence than 'in'
@@ -21,41 +21,57 @@ class Foo {
 
         #p1 in v && #p1 in v; // Good precedence: ((#p1 in v) && (#p1 in v))
     }
+    invalidLHS(v: any) {
+        'prop' in v = 10;
+        #p1 in v = 10;
+    }
 }
 
 class Bar {
     #p1 = 1;
     check(v: any) {
-        #p1 in v; // expect `_p1_1.has(v)`
+        #p1 in v; // expect WeakMap '_p1_1'
     }
 }
 
-function error(v: Foo) {
-    return #p1 in v; // expect `in v`
+function syntaxError(v: Foo) {
+    return #p1 in v; // expect `return in v` so runtime will have a syntax error
 }
 
 export { }
 
 
 //// [privateNameInInExpressionTransform.js]
 // TODO(aclaymore) add cases for static fields
+var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(receiver, privateMap) {
+    if (receiver === null || (typeof receiver !== 'object' && typeof receiver !== 'function')) {
+        throw new TypeError("Cannot use 'in' operator on non-object");
+    }
+    return privateMap.has(receiver);
+};
 var _p1, _p1_1;
 class Foo {
     constructor() {
         _p1.set(this, 1);
     }
     check(v) {
-        _p1.has(v); // expect `_p1.has(v)`
+        __classPrivateFieldIn(v, _p1); // expect WeakMap '_p1'
     }
     precedence(v) {
         // '==' has lower precedence than 'in'
         // '<'  has same precedence than 'in'
         // '<<' has higher precedence than 'in'
-        v == _p1.has(v) == v; // Good precedence: ((v == (#p1 in v)) == v)
-        v << _p1.has(v << v); // Good precedence: (v << (#p1 in (v << v)))
-        v << _p1.has(v) == v; // Good precedence: ((v << (#p1 in v)) == v)
-        v == _p1.has(v) < v; // Good precedence: (v == ((#p1 in v) < v))
-        _p1.has(v) && _p1.has(v); // Good precedence: ((#p1 in v) && (#p1 in v))
+        v == __classPrivateFieldIn(v, _p1) == v; // Good precedence: ((v == (#p1 in v)) == v)
+        v << __classPrivateFieldIn(v << v, _p1); // Good precedence: (v << (#p1 in (v << v)))
+        v << __classPrivateFieldIn(v, _p1) == v; // Good precedence: ((v << (#p1 in v)) == v)
+        v == __classPrivateFieldIn(v, _p1) < v; // Good precedence: (v == ((#p1 in v) < v))
+        __classPrivateFieldIn(v, _p1) && __classPrivateFieldIn(v, _p1); // Good precedence: ((#p1 in v) && (#p1 in v))
+    }
+    invalidLHS(v) {
+        'prop' in v;
+        10;
+        __classPrivateFieldIn(v, _p1);
+        10;
     }
 }
 _p1 = new WeakMap();
@@ -64,11 +80,11 @@ class Bar {
         _p1_1.set(this, 1);
     }
     check(v) {
-        _p1_1.has(v); // expect `_p1_1.has(v)`
+        __classPrivateFieldIn(v, _p1_1); // expect WeakMap '_p1_1'
     }
 }
 _p1_1 = new WeakMap();
-function error(v) {
-    return  in v; // expect `in v`
+function syntaxError(v) {
+    return  in v; // expect `return in v` so runtime will have a syntax error
 }
 export {};

tests/baselines/reference/privateNameInInExpressionTransform.symbols

@@ -11,7 +11,7 @@ class Foo {
 >check : Symbol(Foo.check, Decl(privateNameInInExpressionTransform.ts, 3, 12))
 >v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 4, 10))
 
-        #p1 in v; // expect `_p1.has(v)`
+        #p1 in v; // expect WeakMap '_p1'
 >v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 4, 10))
     }
     precedence(v: any) {
@@ -46,30 +46,40 @@ class Foo {
 >v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 7, 15))
 >v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 7, 15))
     }
+    invalidLHS(v: any) {
+>invalidLHS : Symbol(Foo.invalidLHS, Decl(privateNameInInExpressionTransform.ts, 21, 5))
+>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 22, 15))
+
+        'prop' in v = 10;
+>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 22, 15))
+
+        #p1 in v = 10;
+>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 22, 15))
+    }
 }
 
 class Bar {
->Bar : Symbol(Bar, Decl(privateNameInInExpressionTransform.ts, 22, 1))
+>Bar : Symbol(Bar, Decl(privateNameInInExpressionTransform.ts, 26, 1))
 
     #p1 = 1;
->#p1 : Symbol(Bar.#p1, Decl(privateNameInInExpressionTransform.ts, 24, 11))
+>#p1 : Symbol(Bar.#p1, Decl(privateNameInInExpressionTransform.ts, 28, 11))
 
     check(v: any) {
->check : Symbol(Bar.check, Decl(privateNameInInExpressionTransform.ts, 25, 12))
->v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 26, 10))
+>check : Symbol(Bar.check, Decl(privateNameInInExpressionTransform.ts, 29, 12))
+>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 30, 10))
 
-        #p1 in v; // expect `_p1_1.has(v)`
->v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 26, 10))
+        #p1 in v; // expect WeakMap '_p1_1'
+>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 30, 10))
     }
 }
 
-function error(v: Foo) {
->error : Symbol(error, Decl(privateNameInInExpressionTransform.ts, 29, 1))
->v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 31, 15))
+function syntaxError(v: Foo) {
+>syntaxError : Symbol(syntaxError, Decl(privateNameInInExpressionTransform.ts, 33, 1))
+>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 35, 21))
 >Foo : Symbol(Foo, Decl(privateNameInInExpressionTransform.ts, 0, 0))
 
-    return #p1 in v; // expect `in v`
->v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 31, 15))
+    return #p1 in v; // expect `return in v` so runtime will have a syntax error
+>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 35, 21))
 }
 
 export { }

tests/baselines/reference/privateNameInInExpressionTransform.types

@@ -12,7 +12,7 @@ class Foo {
 >check : (v: any) => void
 >v : any
 
-        #p1 in v; // expect `_p1.has(v)`
+        #p1 in v; // expect WeakMap '_p1'
 >#p1 in v : boolean
 >v : any
     }
@@ -63,6 +63,21 @@ class Foo {
 >#p1 in v : boolean
 >v : Foo
     }
+    invalidLHS(v: any) {
+>invalidLHS : (v: any) => void
+>v : any
+
+        'prop' in v = 10;
+>'prop' in v : boolean
+>'prop' : "prop"
+>v : any
+>10 : 10
+
+        #p1 in v = 10;
+>#p1 in v : boolean
+>v : any
+>10 : 10
+    }
 }
 
 class Bar {
@@ -76,17 +91,17 @@ class Bar {
 >check : (v: any) => void
 >v : any
 
-        #p1 in v; // expect `_p1_1.has(v)`
+        #p1 in v; // expect WeakMap '_p1_1'
 >#p1 in v : boolean
 >v : any
     }
 }
 
-function error(v: Foo) {
->error : (v: Foo) => any
+function syntaxError(v: Foo) {
+>syntaxError : (v: Foo) => any
 >v : Foo
 
-    return #p1 in v; // expect `in v`
+    return #p1 in v; // expect `return in v` so runtime will have a syntax error
 >#p1 in v : any
 >v : Foo
 }

tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts

@@ -5,7 +5,7 @@
 class Foo {
     #p1 = 1;
     check(v: any) {
-        #p1 in v; // expect `_p1.has(v)`
+        #p1 in v; // expect WeakMap '_p1'
     }
     precedence(v: any) {
         // '==' has lower precedence than 'in'
@@ -22,17 +22,21 @@ class Foo {
 
         #p1 in v && #p1 in v; // Good precedence: ((#p1 in v) && (#p1 in v))
     }
+    invalidLHS(v: any) {
+        'prop' in v = 10;
+        #p1 in v = 10;
+    }
 }
 
 class Bar {
     #p1 = 1;
     check(v: any) {
-        #p1 in v; // expect `_p1_1.has(v)`
+        #p1 in v; // expect WeakMap '_p1_1'
     }
 }
 
-function error(v: Foo) {
-    return #p1 in v; // expect `in v`
+function syntaxError(v: Foo) {
+    return #p1 in v; // expect `return in v` so runtime will have a syntax error
 }
 
 export { }