fix(rosetta): arrays aren't handled properly

packages/jsii-rosetta/lib/jsii/jsii-types.ts

@@ -31,6 +31,22 @@ export function determineJsiiType(typeChecker: ts.TypeChecker, type: ts.Type): J
     };
   }
 
+  if (type.symbol?.name === 'Array') {
+    const typeRef = type as ts.TypeReference;
+
+    if (typeRef.typeArguments?.length === 1) {
+      return {
+        kind: 'list',
+        elementType: determineJsiiType(typeChecker, typeRef.typeArguments[0]),
+      };
+    }
+
+    return {
+      kind: 'list',
+      elementType: { kind: 'builtIn', builtIn: 'any' },
+    };
+  }
+
   // User-defined or aliased type
   if (type.aliasSymbol) {
     return { kind: 'namedType', name: type.aliasSymbol.name };

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

@@ -317,6 +317,7 @@ export class CSharpVisitor extends DefaultVisitor<CSharpLanguageContext> {
 
   public parameterDeclaration(node: ts.ParameterDeclaration, renderer: CSharpRenderer): OTree {
     return new OTree([
+      ...(node.dotDotDotToken ? ['params '] : []), // Varargs. Render with 'params' keyword
       this.renderTypeNode(node.type, node.questionToken !== undefined, renderer),
       ' ',
       renderer.convert(node.name),

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

@@ -287,6 +287,13 @@ export abstract class DefaultVisitor<C> implements AstHandler<C> {
     return this.notImplemented(node, context);
   }
 
+  public elementAccessExpression(node: ts.ElementAccessExpression, context: AstRenderer<C>): OTree {
+    const expression = context.convert(node.expression);
+    const index = context.convert(node.argumentExpression);
+
+    return new OTree([expression, '[', index, ']']);
+  }
+
   public nonNullExpression(node: ts.NonNullExpression, context: AstRenderer<C>): OTree {
     // We default we drop the non-null assertion
     return context.convert(node.expression);

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

@@ -262,7 +262,13 @@ export class JavaVisitor extends DefaultVisitor<JavaContext> {
   }
 
   public parameterDeclaration(node: ts.ParameterDeclaration, renderer: JavaRenderer): OTree {
-    return new OTree([this.renderTypeNode(node.type, renderer), ' ', renderer.convert(node.name)]);
+    let renderedType = this.renderTypeNode(node.type, renderer);
+    if (node.dotDotDotToken && renderedType.endsWith('[]')) {
+      // Varargs. In Java, render this as `Element...` (instead of `Element[]` which is what we'll have gotten).
+      renderedType = `${renderedType.substr(0, renderedType.length - 2)}...`;
+    }
+
+    return new OTree([renderedType, ' ', renderer.convert(node.name)]);
   }
 
   public block(node: ts.Block, renderer: JavaRenderer): OTree {
@@ -691,6 +697,7 @@ export class JavaVisitor extends DefaultVisitor<JavaContext> {
     if (!type) {
       return fallback;
     }
+
     return doRender(determineJsiiType(renderer.typeChecker, type), false);
 
     // eslint-disable-next-line consistent-return

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

@@ -301,7 +301,7 @@ export class PythonVisitor extends DefaultVisitor<PythonLanguageContext> {
 
     const suffix = parameterAcceptsUndefined(node, type) ? '=None' : '';
 
-    return new OTree([context.convert(node.name), suffix]);
+    return new OTree([node.dotDotDotToken ? '*' : '', context.convert(node.name), suffix]);
 
     function renderStructProperty(prop: StructProperty): string {
       const sfx = structPropertyAcceptsUndefined(prop) ? '=None' : '';

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

@@ -170,6 +170,10 @@ export class VisualizeAstVisitor implements AstHandler<void> {
     return this.defaultNode('templateExpression', node, context);
   }
 
+  public elementAccessExpression(node: ts.ElementAccessExpression, context: AstRenderer<void>): OTree {
+    return this.defaultNode('elementAccessExpression', node, context);
+  }
+
   public nonNullExpression(node: ts.NonNullExpression, context: AstRenderer<void>): OTree {
     return this.defaultNode('nonNullExpression', node, context);
   }

packages/jsii-rosetta/lib/renderer.ts

@@ -362,6 +362,9 @@ export class AstRenderer<C> {
       }
       return visitor.spreadElement(tree, this);
     }
+    if (ts.isElementAccessExpression(tree)) {
+      return visitor.elementAccessExpression(tree, this);
+    }
     if (ts.isTemplateExpression(tree)) {
       return visitor.templateExpression(tree, this);
     }
@@ -492,6 +495,7 @@ export interface AstHandler<C> {
   nonNullExpression(node: ts.NonNullExpression, context: AstRenderer<C>): OTree;
   parenthesizedExpression(node: ts.ParenthesizedExpression, context: AstRenderer<C>): OTree;
   maskingVoidExpression(node: ts.VoidExpression, context: AstRenderer<C>): OTree;
+  elementAccessExpression(node: ts.ElementAccessExpression, context: AstRenderer<C>): OTree;
 
   // Not a node, called when we recognize a spread element/assignment that is only
   // '...' and nothing else.

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

@@ -0,0 +1,3 @@
+string[] array;
+
+Console.WriteLine(array[3]);

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

@@ -0,0 +1,3 @@
+String[] array;
+
+System.out.println(array[3]);

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

@@ -0,0 +1,3 @@
+# array is of type list of string
+
+print(array[3])

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

@@ -0,0 +1,3 @@
+declare const array: string[];
+
+console.log(array[3]);

packages/jsii-rosetta/test/translations/statements/vararg_any_call.cs

@@ -1,4 +1,4 @@
-public void Test(Array _args)
+public void Test(params object[] _args)
 {
 }
 

packages/jsii-rosetta/test/translations/statements/vararg_any_call.java

@@ -1,4 +1,4 @@
-public void test(Array _args) {
+public void test(Object... _args) {
 }
 
 test(Map.of("Key", "Value", "also", 1337));

packages/jsii-rosetta/test/translations/statements/vararg_any_call.py

@@ -1,4 +1,4 @@
-def test(_args):
+def test(*_args):
     pass
 
 test({"Key": "Value", "also": 1337})