@@ -221,7 +221,10 @@ export function checkForLuaLibType(context: TransformationContext, type: ts.Type
     }
 }
 
-function tryGetStandardLibrarySymbolOfType(context: TransformationContext, type: ts.Type): ts.Symbol | undefined {
+export function tryGetStandardLibrarySymbolOfType(
+    context: TransformationContext,
+    type: ts.Type
+): ts.Symbol | undefined {
     if (type.isUnionOrIntersection()) {
         for (const subType of type.types) {
             const symbol = tryGetStandardLibrarySymbolOfType(context, subType);
 
@@ -172,3 +172,7 @@ export const cannotAssignToNodeOfKind = createErrorDiagnosticFactory(
 export const incompleteFieldDecoratorWarning = createWarningDiagnosticFactory(
     "You are using a class field decorator, note that tstl ignores returned value initializers!"
 );
+
+export const unsupportedArrayWithLengthConstructor = createErrorDiagnosticFactory(
+    `Constructing new Array with length is not supported.`
+);
@@ -2,16 +2,42 @@ import * as ts from "typescript";
 import * as lua from "../../../LuaAST";
 import { FunctionVisitor } from "../../context";
 import { AnnotationKind, getTypeAnnotations } from "../../utils/annotations";
-import { annotationInvalidArgumentCount } from "../../utils/diagnostics";
+import { annotationInvalidArgumentCount, unsupportedArrayWithLengthConstructor } from "../../utils/diagnostics";
 import { LuaLibFeature, transformLuaLibFunction } from "../../utils/lualib";
 import { transformArguments, transformCallAndArguments } from "../call";
 import { isTableNewCall } from "../language-extensions/table";
+import { tryGetStandardLibrarySymbolOfType } from "../../builtins";
 
 export const transformNewExpression: FunctionVisitor<ts.NewExpression> = (node, context) => {
     if (isTableNewCall(context, node)) {
         return lua.createTableExpression(undefined, node);
     }
 
+    const constructorType = context.checker.getTypeAtLocation(node.expression);
+    if (tryGetStandardLibrarySymbolOfType(context, constructorType)?.name === "ArrayConstructor") {
+        if (node.arguments === undefined || node.arguments.length === 0) {
+            // turn new Array<>() into a simple {}
+            return lua.createTableExpression([], node);
+        } else {
+            // More than one argument, check if items constructor
+            const signature = context.checker.getResolvedSignature(node);
+            const signatureDeclaration = signature?.getDeclaration();
+            if (
+                signatureDeclaration?.parameters.length === 1 &&
+                signatureDeclaration.parameters[0].dotDotDotToken === undefined
+            ) {
+                context.diagnostics.push(unsupportedArrayWithLengthConstructor(node));
+                return lua.createTableExpression([], node);
+            } else {
+                const callArguments = transformArguments(context, node.arguments, signature);
+                return lua.createTableExpression(
+                    callArguments.map(e => lua.createTableFieldExpression(e)),
+                    node
+                );
+            }
+        }
+    }
+
     const signature = context.checker.getResolvedSignature(node);
     const [name, params] = transformCallAndArguments(context, node.expression, node.arguments ?? [], signature);
 
 
@@ -1,4 +1,7 @@
-import { undefinedInArrayLiteral } from "../../../src/transformation/utils/diagnostics";
+import {
+    undefinedInArrayLiteral,
+    unsupportedArrayWithLengthConstructor,
+} from "../../../src/transformation/utils/diagnostics";
 import * as util from "../../util";
 
 test("omitted expression", () => {
@@ -898,3 +901,31 @@ test("array indexing in optional chain (#1605)", () => {
         .setOptions({ strict: true }) // crucial to reproducing for some reason
         .expectToMatchJsResult();
 });
+
+test("new Array()", () => {
+    util.testFunction`
+        const arr = new Array();
+        arr.push(1,2,3);
+        return arr;
+    `
+        .debug()
+        .expectToMatchJsResult();
+});
+
+test("new Array<T>()", () => {
+    util.testFunction`
+        const arr = new Array<number>();
+        arr.push(1,2,3);
+        return arr;
+    `.expectToMatchJsResult();
+});
+
+test("new Array<T>(length)", () => {
+    util.testFunction`
+        const arr = new Array<string>(10);
+    `.expectToHaveDiagnostics([unsupportedArrayWithLengthConstructor.code]);
+});
+
+test("new Array<T>(...items)", () => {
+    util.testExpression`new Array(1,2,3,4,5) `.expectToMatchJsResult();
+});
Original file line number	Diff line number	Diff line change
`@@ -221,7 +221,10 @@ export function checkForLuaLibType(context: TransformationContext, type: ts.Type`
`221`	`221`	`}`
`222`	`222`	`}`
`223`	`223`
`224`		`-function tryGetStandardLibrarySymbolOfType(context: TransformationContext, type: ts.Type): ts.Symbol \| undefined {`
	`224`	`+export function tryGetStandardLibrarySymbolOfType(`
	`225`	`+ context: TransformationContext,`
	`226`	`+ type: ts.Type`
	`227`	`+): ts.Symbol \| undefined {`
`225`	`228`	`if (type.isUnionOrIntersection()) {`
`226`	`229`	`for (const subType of type.types) {`
`227`	`230`	`const symbol = tryGetStandardLibrarySymbolOfType(context, subType);`