fix(rosetta): fix translation of ! and === operators

packages/jsii-rosetta/lib/languages/default.ts

@@ -63,17 +63,23 @@ export abstract class DefaultVisitor<C> implements AstHandler<C> {
   }
 
   public binaryExpression(node: ts.BinaryExpression, context: AstRenderer<C>): OTree {
-    return new OTree([
-      context.convert(node.left),
-      ' ',
-      context.textOf(node.operatorToken),
-      ' ',
-      context.convert(node.right),
-    ]);
+    const operatorToken = this.translateBinaryOperator(context.textOf(node.operatorToken));
+    return new OTree([context.convert(node.left), ' ', operatorToken, ' ', context.convert(node.right)]);
   }
 
   public prefixUnaryExpression(node: ts.PrefixUnaryExpression, context: AstRenderer<C>): OTree {
-    return new OTree([UNARY_OPS[node.operator], context.convert(node.operand)]);
+    return new OTree([this.translateUnaryOperator(node.operator), context.convert(node.operand)]);
+  }
+
+  public translateUnaryOperator(operator: ts.PrefixUnaryOperator) {
+    return UNARY_OPS[operator];
+  }
+
+  public translateBinaryOperator(operator: string) {
+    if (operator === '===') {
+      return '==';
+    }
+    return operator;
   }
 
   public ifStatement(node: ts.IfStatement, context: AstRenderer<C>): OTree {
@@ -153,6 +159,7 @@ export abstract class DefaultVisitor<C> implements AstHandler<C> {
       return this.unknownTypeObjectLiteralExpression(node, context);
     }
     if (isKnownStruct) {
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
       return this.knownStructObjectLiteralExpression(node, type!, context);
     }
     return this.keyValueObjectLiteralExpression(node, type && mapElementType(type, context.typeChecker), context);
@@ -329,7 +336,7 @@ const UNARY_OPS: { [op in ts.PrefixUnaryOperator]: string } = {
   [ts.SyntaxKind.PlusToken]: '+',
   [ts.SyntaxKind.MinusToken]: '-',
   [ts.SyntaxKind.TildeToken]: '~',
-  [ts.SyntaxKind.ExclamationToken]: '~',
+  [ts.SyntaxKind.ExclamationToken]: '!',
 };
 
 function findEnclosingCallExpression(node?: ts.Node): ts.CallLikeExpression | undefined {

packages/jsii-rosetta/lib/languages/python.ts

@@ -354,6 +354,13 @@ export class PythonVisitor extends DefaultVisitor<PythonLanguageContext> {
     return this.renderObjectLiteralExpression('{', '}', false, node, context);
   }
 
+  public translateUnaryOperator(operator: ts.PrefixUnaryOperator) {
+    if (operator === ts.SyntaxKind.ExclamationToken) {
+      return 'not ';
+    }
+    return super.translateUnaryOperator(operator);
+  }
+
   public renderObjectLiteralExpression(
     prefix: string,
     suffix: string,

packages/jsii-rosetta/test/translations/expressions/unary_and_binary_operators.cs

@@ -0,0 +1,3 @@
+Console.WriteLine(-3);
+Console.WriteLine(!false);
+Console.WriteLine(a == b);

packages/jsii-rosetta/test/translations/expressions/unary_and_binary_operators.java

@@ -0,0 +1,3 @@
+System.out.println(-3);
+System.out.println(!false);
+System.out.println(a == b);

packages/jsii-rosetta/test/translations/expressions/unary_and_binary_operators.py

@@ -0,0 +1,3 @@
+print(-3)
+print(not False)
+print(a == b)

packages/jsii-rosetta/test/translations/expressions/unary_and_binary_operators.ts

@@ -0,0 +1,3 @@
+console.log(-3);
+console.log(!false);
+console.log(a === b);