test.ts.lint

let x: Array<undefined> = [undefined] as undefined[];
       ~~~~~~~~~~~~~~~~                               [0]
let xx: Array<object> = [];
        ~~~~~~~~~~~~~ [0]
let y: string[] = <Array<string>>["2"];
                   ~~~~~~~~~~~~~        [0]
let z: Array = [3, "4"];
       ~~~~~             [0]
let u: Array<unknown> = [];
       ~~~~~~~~~~~~~~       [0]

let xx: Array<Array<number>> = [[1, 2], [3]];
        ~~~~~~~~~~~~~~~~~~~~                  [0]
              ~~~~~~~~~~~~~                   [0]
let yy: number[][] = [[4, 5], [6]];

let ya = [[1, "2"]] as[number, string][];
                      ~~~~~~~~~~~~~~~~~~  [Array type using 'T[]' is forbidden for non-simple types. Use 'Array<T>' instead.]

type Arr<T> = Array<T>;
              ~~~~~~~~  [0]
type ParenthesisArr<T> = (T)[];
type DoubleParenthesisArr<T> = ((T))[];

// Ignore user defined aliases
let yyyy: Arr<Array<Arr<string>>[]> = [[[["2"]]]];
              ~~~~~~~~~~~~~~~~~~~~                 [Array type using 'T[]' is forbidden for non-simple types. Use 'Array<T>' instead.]

interface ArrayClass<T> {
    foo: Array<T>;
         ~~~~~~~~  [0]
    bar: T[];
    baz: Arr<T>;
    xyz: this[];
}

function fooFunction(foo: Array<ArrayClass<string>>) {
    return foo.map(e => e.foo);
}

function barFunction(bar: ArrayClass<String>[]) {
                          ~~~~~~~~~~~~~~~~~~~~    [Array type using 'T[]' is forbidden for non-simple types. Use 'Array<T>' instead.]
    return bar.map(e => e.bar);
}

function bazFunction(baz: Arr<ArrayClass<String>>) {
    return baz.map(e => e.baz);
}

let fooVar: Array<(c: number) => number>;
let barVar: ((c: number) => number)[];
            ~~~~~~~~~~~~~~~~~~~~~~~~~  [Array type using 'T[]' is forbidden for non-simple types. Use 'Array<T>' instead.]

type fooUnion = Array<string|number|boolean>;
type barUnion = (string|number|boolean)[];
                ~~~~~~~~~~~~~~~~~~~~~~~~~  [Array type using 'T[]' is forbidden for non-simple types. Use 'Array<T>' instead.]
type bazUnion = ((string|number|boolean))[];
                ~~~~~~~~~~~~~~~~~~~~~~~~~~~  [Array type using 'T[]' is forbidden for non-simple types. Use 'Array<T>' instead.]

type fooIntersection = Array<string & number>;
type barIntersection = (string & number)[];
                       ~~~~~~~~~~~~~~~~~~~  [Array type using 'T[]' is forbidden for non-simple types. Use 'Array<T>' instead.]
type bazIntersection = ((string & number))[];
                       ~~~~~~~~~~~~~~~~~~~~~  [Array type using 'T[]' is forbidden for non-simple types. Use 'Array<T>' instead.]

namespace fooName {
    type BarType = { bar: string };
    type BazType<T> = Arr<T>;
}

let v: Array<fooName.BarType> = [{ bar: "bar" }];
       ~~~~~~~~~~~~~~~~~~~~~~                     [0]

let w: fooName.BazType<string>[] = [["baz"]];
       ~~~~~~~~~~~~~~~~~~~~~~~~~              [Array type using 'T[]' is forbidden for non-simple types. Use 'Array<T>' instead.]

interface FooInterface {
    '.bar': {baz: string[];};
}

// Test an unknown Array
let t: unknown[] = [];
let u: Array<unknown> = [];
       ~~~~~~~~~~~~~~       [0]

[0]: Array type using 'Array<T>' is forbidden for simple types. Use 'T[]' instead.