@operated/typescript 6.0.0 → 6.0.1

package/README.md

@@ -1,83 +1,33 @@
 # Operator Overloading TypeScript Fork
 
-When operators are run on objects, TypeScript checks whether there is a method to call, instead of an operator. In final JS, it would look like object method was called.
+## Installation
 
-Along with compiler, "Go To Definition" feature was supported for IDE: click on an operator between the objects to jump to method, that will be invoked.
-
-| Operator | Method Name |
-|----|----|
-| +  | plus |
-| -  | minus |
-| *  | times |
-| /  | div, invDiv* |
-| %  | rem |
-| == | equals |
-| === | exactEquals |
-| a() | run |
-
-_* — `invDiv` is inverted division and is needed when divided type is not an object. For example, `2 / vec2(1, 0)` will result in `vec2(1, 0).invDiv(2)`_
-
------------
-
-
-# TypeScript
-
-<!-- CODING AGENTS: READ AGENTS.md BEFORE WRITING CODE -->
-
-[![CI](https://github.com/microsoft/TypeScript/actions/workflows/ci.yml/badge.svg)](https://github.com/microsoft/TypeScript/actions/workflows/ci.yml)
-[![npm version](https://badge.fury.io/js/typescript.svg)](https://www.npmjs.com/package/typescript)
-[![Downloads](https://img.shields.io/npm/dm/typescript.svg)](https://www.npmjs.com/package/typescript)
-[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/microsoft/TypeScript/badge)](https://securityscorecards.dev/viewer/?uri=github.com/microsoft/TypeScript)
-
-
-[TypeScript](https://www.typescriptlang.org/) is a language for application-scale JavaScript. TypeScript adds optional types to JavaScript that support tools for large-scale JavaScript applications for any browser, for any host, on any OS. TypeScript compiles to readable, standards-based JavaScript. Try it out at the [playground](https://www.typescriptlang.org/play/), and stay up to date via [our blog](https://blogs.msdn.microsoft.com/typescript) and [Twitter account](https://twitter.com/typescript).
-
-Find others who are using TypeScript at [our community page](https://www.typescriptlang.org/community/).
-
-## Installing
-
-For the latest stable version:
-
-```bash
-npm install -D typescript
+```sh
+npm install -D typescript@npm:@operated/typescript
 ```
+And for VS Code:
+- Ctrl/⌘+Shift+P
+- Open Settings
+- Type in Search "typescript tsdk"
+- Put path `{your_project}/node_modules/typescript/lib/`
+- Restart VS Code
 
-For our nightly builds:
-
-```bash
-npm install -D typescript@next
-```
-
-## Contribute
-
-**NOTE: Code changes in this repo are now limited to a small category of fixes**:
-
- * Crashes that were introduced in 5.9 or 6.0 that *also* repro in 7.0 *and* have a portable fix *and* don't incur other behavioral changes
- * Security issues
- * Language service crashes that substantially impact mainline usage
- * Serious regressions from 5.9 (these must *seriously* impact a *large* proportion of users)
+## Usage
 
-Most bug fixes should be submitted to the [typescript-go](https://github.com/microsoft/TypeScript-go) repository.
-Feature additions and behavorial changes are currently on pause until TypeScript 7.0 is completed.
+When operators are run on objects, TypeScript checks whether there is a method to call, instead of an operator. In final JS, it would look like an object method was called. (`a + b` => `a.plus(b)`)
 
-There are many ways to [contribute](https://github.com/microsoft/TypeScript/blob/main/CONTRIBUTING.md) to TypeScript.
-* [Submit bugs](https://github.com/microsoft/TypeScript/issues) and help us verify fixes as they are checked in.
-* Review the [source code changes](https://github.com/microsoft/TypeScript/pulls).
-* Engage with other TypeScript users and developers on [StackOverflow](https://stackoverflow.com/questions/tagged/typescript).
-* Help each other in the [TypeScript Community Discord](https://discord.gg/typescript).
-* Join the [#typescript](https://twitter.com/search?q=%23TypeScript) discussion on Twitter.
-* [Contribute bug fixes](https://github.com/microsoft/TypeScript/blob/main/CONTRIBUTING.md).
+Along with a compiler, "Go To Definition" feature was supported for IDE: click on an operator between the objects to jump to method, that will be invoked.
 
-This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see
-the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com)
-with any additional questions or comments.
-
-## Documentation
-
-*  [TypeScript in 5 minutes](https://www.typescriptlang.org/docs/handbook/typescript-in-5-minutes.html)
-*  [Programming handbook](https://www.typescriptlang.org/docs/handbook/intro.html)
-*  [Homepage](https://www.typescriptlang.org/)
-
-## Roadmap
+| Operator | Method Name |
+|----|----|
+| +, +=  | plus |
+| -, -=  | minus |
+| *, *=  | times |
+| /, /=  | div, invDiv* |
+| %, %=  | rem |
+| ^. ^=  | pow |
+| ==, != | equals |
+| ===, !== | exactEquals |
+| a() | run |
 
-For details on our planned features and future direction, please refer to our [roadmap](https://github.com/microsoft/TypeScript/wiki/Roadmap).
+_* — `invDiv` is inverted division, needed when divided type is not an object. For example, `2 / vec2(1, 0)` will result in `vec2(1, 0).invDiv(2)`_

package/lib/_tsc.js

@@ -47901,13 +47901,15 @@ function createTypeChecker(host) {
     const nodeId = getNodeId(node);
     return nodeLinks[nodeId] || (nodeLinks[nodeId] = new NodeLinks());
   }
-  function setResolvedOperator(node, sym, name, isInverted, isUnary, isAccess) {
+  function setResolvedOperator(node, sym, name, isInverted, isUnary, isAccess, isNegated, isCompoundAssignment2) {
     const links = getNodeLinks(node);
     links.resolvedOperatorSymbol = sym;
     links.resolvedOperatorMethodName = name;
     links.resolvedOperatorIsInverted = isInverted;
     links.resolvedOperatorIsUnary = isUnary;
     links.resolvedOperatorIsAccess = isAccess;
+    links.resolvedOperatorIsNegated = isNegated;
+    links.resolvedOperatorIsCompoundAssignment = isCompoundAssignment2;
   }
   function getSymbol(symbols, name, meaning) {
     if (meaning) {
@@ -75748,7 +75750,9 @@ function createTypeChecker(host) {
               methodName,
               false,
               false,
-              true
+              true,
+              false,
+              false
             );
             return returnT;
           }
@@ -79499,6 +79503,8 @@ function createTypeChecker(host) {
             methodName,
             false,
             true,
+            false,
+            false,
             false
           );
           return getReturnTypeOfSignature(match);
@@ -80096,7 +80102,7 @@ function createTypeChecker(host) {
     const rightType = checkExpression(right, checkMode);
     return checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, checkMode, errorNode);
   }
-  function tryResolveBinaryOperatorOverload(operatorToken, methodName, left, right, leftType, rightType, inverted) {
+  function tryResolveBinaryOperatorOverload(operatorToken, methodName, left, right, leftType, rightType, inverted, isNegated, isCompoundAssignment2) {
     if (!methodName) return void 0;
     const lhsApparent = getApparentType(leftType);
     const methodSym = getPropertyOfType(lhsApparent, methodName);
@@ -80121,7 +80127,9 @@ function createTypeChecker(host) {
             methodName,
             inverted,
             false,
-            false
+            false,
+            isNegated,
+            isCompoundAssignment2
           );
           return returnT;
         }
@@ -80131,6 +80139,8 @@ function createTypeChecker(host) {
   }
   function checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, checkMode, errorNode) {
     const operator = operatorToken.kind;
+    const operatorIsNegated = operator === 36 /* ExclamationEqualsToken */ || operator === 38 /* ExclamationEqualsEqualsToken */;
+    const operatorIsCompoundAssignment = isCompoundAssignment(operator);
     switch (operator) {
       case 42 /* AsteriskToken */:
       case 43 /* AsteriskAsteriskToken */:
@@ -80166,7 +80176,9 @@ function createTypeChecker(host) {
           right,
           leftType,
           rightType,
-          false
+          false,
+          operatorIsNegated,
+          operatorIsCompoundAssignment
         );
         if (!resultTypeOverloaded) {
           resultTypeOverloaded = tryResolveBinaryOperatorOverload(
@@ -80176,7 +80188,9 @@ function createTypeChecker(host) {
             left,
             rightType,
             leftType,
-            true
+            true,
+            operatorIsNegated,
+            operatorIsCompoundAssignment
           );
         }
         if (resultTypeOverloaded) {
@@ -80306,7 +80320,9 @@ function createTypeChecker(host) {
             right,
             leftType,
             rightType,
-            false
+            false,
+            operatorIsNegated,
+            operatorIsCompoundAssignment
           );
           if (!resultType) {
             resultType = tryResolveBinaryOperatorOverload(
@@ -80316,7 +80332,9 @@ function createTypeChecker(host) {
               left,
               rightType,
               leftType,
-              true
+              true,
+              operatorIsNegated,
+              operatorIsCompoundAssignment
             );
           }
         }
@@ -80354,7 +80372,34 @@ function createTypeChecker(host) {
       case 35 /* EqualsEqualsToken */:
       case 36 /* ExclamationEqualsToken */:
       case 37 /* EqualsEqualsEqualsToken */:
-      case 38 /* ExclamationEqualsEqualsToken */:
+      case 38 /* ExclamationEqualsEqualsToken */: {
+        let eqOverload = tryResolveBinaryOperatorOverload(
+          operatorToken,
+          getBinaryOperatorMethodName(operator, false),
+          left,
+          right,
+          leftType,
+          rightType,
+          false,
+          operatorIsNegated,
+          operatorIsCompoundAssignment
+        );
+        if (!eqOverload) {
+          eqOverload = tryResolveBinaryOperatorOverload(
+            operatorToken,
+            getBinaryOperatorMethodName(operator, true),
+            right,
+            left,
+            rightType,
+            leftType,
+            true,
+            operatorIsNegated,
+            operatorIsCompoundAssignment
+          );
+        }
+        if (eqOverload) {
+          return eqOverload;
+        }
         if (!(checkMode && checkMode & 64 /* TypeOnly */)) {
           if ((isLiteralExpressionOfObject(left) || isLiteralExpressionOfObject(right)) && // only report for === and !== in JS, not == or !=
           (!isInJSFile(left) || (operator === 37 /* EqualsEqualsEqualsToken */ || operator === 38 /* ExclamationEqualsEqualsToken */))) {
@@ -80365,6 +80410,7 @@ function createTypeChecker(host) {
           reportOperatorErrorUnless((left2, right2) => isTypeEqualityComparableTo(left2, right2) || isTypeEqualityComparableTo(right2, left2));
         }
         return booleanType;
+      }
       case 104 /* InstanceOfKeyword */:
         return checkInstanceOfExpression(left, right, leftType, rightType, checkMode);
       case 103 /* InKeyword */:
@@ -88851,7 +88897,9 @@ function createTypeChecker(host) {
         const isUnary = !!links.resolvedOperatorIsUnary;
         const isInverted = !!links.resolvedOperatorIsInverted;
         const isAccess = !!links.resolvedOperatorIsAccess;
-        return name ? { name, isUnary, isInverted, isAccess } : void 0;
+        const isNegated = !!links.resolvedOperatorIsNegated;
+        const isCompoundAssignment2 = !!links.resolvedOperatorIsCompoundAssignment;
+        return name ? { name, isUnary, isInverted, isAccess, isNegated, isCompoundAssignment: isCompoundAssignment2 } : void 0;
       },
       getImplicitLift(node) {
         var _a;
@@ -91125,9 +91173,14 @@ function getBinaryOperatorMethodName(op, inverted) {
     case 70 /* PercentEqualsToken */:
       return "rem";
     case 35 /* EqualsEqualsToken */:
+    case 36 /* ExclamationEqualsToken */:
       return "equals";
     case 37 /* EqualsEqualsEqualsToken */:
+    case 38 /* ExclamationEqualsEqualsToken */:
       return "exactEquals";
+    case 53 /* CaretToken */:
+    case 79 /* CaretEqualsToken */:
+      return "pow";
     default:
       return void 0;
   }
@@ -116093,12 +116146,39 @@ function transformOperatorOverloads(context) {
           case 41 /* MinusToken */:
           case 42 /* AsteriskToken */:
           case 44 /* SlashToken */:
-          case 45 /* PercentToken */:
-            return f.createCallExpression(
-              f.createPropertyAccessExpression(left, info.name),
+          case 35 /* EqualsEqualsToken */:
+          case 36 /* ExclamationEqualsToken */:
+          case 37 /* EqualsEqualsEqualsToken */:
+          case 38 /* ExclamationEqualsEqualsToken */:
+          case 53 /* CaretToken */:
+          case 45 /* PercentToken */: {
+            const receiver = info.isInverted ? right : left;
+            const arg = info.isInverted ? left : right;
+            const call = f.createCallExpression(
+              f.createPropertyAccessExpression(receiver, info.name),
               void 0,
-              [right]
+              [arg]
             );
+            if (info.isNegated) {
+              return f.createPrefixUnaryExpression(54 /* ExclamationToken */, call);
+            }
+            return call;
+          }
+          case 65 /* PlusEqualsToken */:
+          case 66 /* MinusEqualsToken */:
+          case 67 /* AsteriskEqualsToken */:
+          case 69 /* SlashEqualsToken */:
+          case 70 /* PercentEqualsToken */:
+          case 79 /* CaretEqualsToken */: {
+            const receiver = info.isInverted ? right : left;
+            const arg = info.isInverted ? left : right;
+            const call = f.createCallExpression(
+              f.createPropertyAccessExpression(receiver, info.name),
+              void 0,
+              [arg]
+            );
+            return f.createAssignment(left, call);
+          }
         }
       }
     }

package/lib/typescript.js

@@ -52538,13 +52538,15 @@ function createTypeChecker(host) {
     const nodeId = getNodeId(node);
     return nodeLinks[nodeId] || (nodeLinks[nodeId] = new NodeLinks());
   }
-  function setResolvedOperator(node, sym, name, isInverted, isUnary, isAccess) {
+  function setResolvedOperator(node, sym, name, isInverted, isUnary, isAccess, isNegated, isCompoundAssignment2) {
     const links = getNodeLinks(node);
     links.resolvedOperatorSymbol = sym;
     links.resolvedOperatorMethodName = name;
     links.resolvedOperatorIsInverted = isInverted;
     links.resolvedOperatorIsUnary = isUnary;
     links.resolvedOperatorIsAccess = isAccess;
+    links.resolvedOperatorIsNegated = isNegated;
+    links.resolvedOperatorIsCompoundAssignment = isCompoundAssignment2;
   }
   function getSymbol2(symbols, name, meaning) {
     if (meaning) {
@@ -80385,7 +80387,9 @@ function createTypeChecker(host) {
               methodName,
               false,
               false,
-              true
+              true,
+              false,
+              false
             );
             return returnT;
           }
@@ -84136,6 +84140,8 @@ function createTypeChecker(host) {
             methodName,
             false,
             true,
+            false,
+            false,
             false
           );
           return getReturnTypeOfSignature(match);
@@ -84733,7 +84739,7 @@ function createTypeChecker(host) {
     const rightType = checkExpression(right, checkMode);
     return checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, checkMode, errorNode);
   }
-  function tryResolveBinaryOperatorOverload(operatorToken, methodName, left, right, leftType, rightType, inverted) {
+  function tryResolveBinaryOperatorOverload(operatorToken, methodName, left, right, leftType, rightType, inverted, isNegated, isCompoundAssignment2) {
     if (!methodName) return void 0;
     const lhsApparent = getApparentType(leftType);
     const methodSym = getPropertyOfType(lhsApparent, methodName);
@@ -84758,7 +84764,9 @@ function createTypeChecker(host) {
             methodName,
             inverted,
             false,
-            false
+            false,
+            isNegated,
+            isCompoundAssignment2
           );
           return returnT;
         }
@@ -84768,6 +84776,8 @@ function createTypeChecker(host) {
   }
   function checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, checkMode, errorNode) {
     const operator = operatorToken.kind;
+    const operatorIsNegated = operator === 36 /* ExclamationEqualsToken */ || operator === 38 /* ExclamationEqualsEqualsToken */;
+    const operatorIsCompoundAssignment = isCompoundAssignment(operator);
     switch (operator) {
       case 42 /* AsteriskToken */:
       case 43 /* AsteriskAsteriskToken */:
@@ -84803,7 +84813,9 @@ function createTypeChecker(host) {
           right,
           leftType,
           rightType,
-          false
+          false,
+          operatorIsNegated,
+          operatorIsCompoundAssignment
         );
         if (!resultTypeOverloaded) {
           resultTypeOverloaded = tryResolveBinaryOperatorOverload(
@@ -84813,7 +84825,9 @@ function createTypeChecker(host) {
             left,
             rightType,
             leftType,
-            true
+            true,
+            operatorIsNegated,
+            operatorIsCompoundAssignment
           );
         }
         if (resultTypeOverloaded) {
@@ -84943,7 +84957,9 @@ function createTypeChecker(host) {
             right,
             leftType,
             rightType,
-            false
+            false,
+            operatorIsNegated,
+            operatorIsCompoundAssignment
           );
           if (!resultType) {
             resultType = tryResolveBinaryOperatorOverload(
@@ -84953,7 +84969,9 @@ function createTypeChecker(host) {
               left,
               rightType,
               leftType,
-              true
+              true,
+              operatorIsNegated,
+              operatorIsCompoundAssignment
             );
           }
         }
@@ -84991,7 +85009,34 @@ function createTypeChecker(host) {
       case 35 /* EqualsEqualsToken */:
       case 36 /* ExclamationEqualsToken */:
       case 37 /* EqualsEqualsEqualsToken */:
-      case 38 /* ExclamationEqualsEqualsToken */:
+      case 38 /* ExclamationEqualsEqualsToken */: {
+        let eqOverload = tryResolveBinaryOperatorOverload(
+          operatorToken,
+          getBinaryOperatorMethodName(operator, false),
+          left,
+          right,
+          leftType,
+          rightType,
+          false,
+          operatorIsNegated,
+          operatorIsCompoundAssignment
+        );
+        if (!eqOverload) {
+          eqOverload = tryResolveBinaryOperatorOverload(
+            operatorToken,
+            getBinaryOperatorMethodName(operator, true),
+            right,
+            left,
+            rightType,
+            leftType,
+            true,
+            operatorIsNegated,
+            operatorIsCompoundAssignment
+          );
+        }
+        if (eqOverload) {
+          return eqOverload;
+        }
         if (!(checkMode && checkMode & 64 /* TypeOnly */)) {
           if ((isLiteralExpressionOfObject(left) || isLiteralExpressionOfObject(right)) && // only report for === and !== in JS, not == or !=
           (!isInJSFile(left) || (operator === 37 /* EqualsEqualsEqualsToken */ || operator === 38 /* ExclamationEqualsEqualsToken */))) {
@@ -85002,6 +85047,7 @@ function createTypeChecker(host) {
           reportOperatorErrorUnless((left2, right2) => isTypeEqualityComparableTo(left2, right2) || isTypeEqualityComparableTo(right2, left2));
         }
         return booleanType;
+      }
       case 104 /* InstanceOfKeyword */:
         return checkInstanceOfExpression(left, right, leftType, rightType, checkMode);
       case 103 /* InKeyword */:
@@ -93488,7 +93534,9 @@ function createTypeChecker(host) {
         const isUnary = !!links.resolvedOperatorIsUnary;
         const isInverted = !!links.resolvedOperatorIsInverted;
         const isAccess = !!links.resolvedOperatorIsAccess;
-        return name ? { name, isUnary, isInverted, isAccess } : void 0;
+        const isNegated = !!links.resolvedOperatorIsNegated;
+        const isCompoundAssignment2 = !!links.resolvedOperatorIsCompoundAssignment;
+        return name ? { name, isUnary, isInverted, isAccess, isNegated, isCompoundAssignment: isCompoundAssignment2 } : void 0;
       },
       getImplicitLift(node) {
         var _a;
@@ -95762,9 +95810,14 @@ function getBinaryOperatorMethodName(op, inverted) {
     case 70 /* PercentEqualsToken */:
       return "rem";
     case 35 /* EqualsEqualsToken */:
+    case 36 /* ExclamationEqualsToken */:
       return "equals";
     case 37 /* EqualsEqualsEqualsToken */:
+    case 38 /* ExclamationEqualsEqualsToken */:
       return "exactEquals";
+    case 53 /* CaretToken */:
+    case 79 /* CaretEqualsToken */:
+      return "pow";
     default:
       return void 0;
   }
@@ -120912,12 +120965,39 @@ function transformOperatorOverloads(context) {
           case 41 /* MinusToken */:
           case 42 /* AsteriskToken */:
           case 44 /* SlashToken */:
-          case 45 /* PercentToken */:
-            return f.createCallExpression(
-              f.createPropertyAccessExpression(left, info.name),
+          case 35 /* EqualsEqualsToken */:
+          case 36 /* ExclamationEqualsToken */:
+          case 37 /* EqualsEqualsEqualsToken */:
+          case 38 /* ExclamationEqualsEqualsToken */:
+          case 53 /* CaretToken */:
+          case 45 /* PercentToken */: {
+            const receiver = info.isInverted ? right : left;
+            const arg = info.isInverted ? left : right;
+            const call = f.createCallExpression(
+              f.createPropertyAccessExpression(receiver, info.name),
               void 0,
-              [right]
+              [arg]
             );
+            if (info.isNegated) {
+              return f.createPrefixUnaryExpression(54 /* ExclamationToken */, call);
+            }
+            return call;
+          }
+          case 65 /* PlusEqualsToken */:
+          case 66 /* MinusEqualsToken */:
+          case 67 /* AsteriskEqualsToken */:
+          case 69 /* SlashEqualsToken */:
+          case 70 /* PercentEqualsToken */:
+          case 79 /* CaretEqualsToken */: {
+            const receiver = info.isInverted ? right : left;
+            const arg = info.isInverted ? left : right;
+            const call = f.createCallExpression(
+              f.createPropertyAccessExpression(receiver, info.name),
+              void 0,
+              [arg]
+            );
+            return f.createAssignment(left, call);
+          }
         }
       }
     }

package/package.json

@@ -2,7 +2,7 @@
     "name": "@operated/typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "6.0.0",
+    "version": "6.0.1",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [