Use T[] for arrays and as T for casts throughout (#461)

packages/adl/compiler/binder.ts

@@ -35,7 +35,7 @@ export interface DecoratorSymbol {
   kind: "decorator";
   path: string;
   name: string;
-  value: (...args: Array<any>) => any;
+  value: (...args: any[]) => any;
 }
 
 export interface TypeSymbol {

packages/adl/compiler/character-codes.ts

@@ -202,7 +202,7 @@ export function isIdentifierPart(ch: number): boolean {
   );
 }
 
-function lookupInUnicodeMap(code: number, map: ReadonlyArray<number>): boolean {
+function lookupInUnicodeMap(code: number, map: readonly number[]): boolean {
   // Bail out quickly if it couldn't possibly be in the map.
   if (code < map[0]) {
     return false;

packages/adl/compiler/checker.ts

@@ -51,17 +51,17 @@ export class MultiKeyMap<T> {
   #idMap = new WeakMap<object, number>();
   #items = new Map<string, T>();
 
-  get(items: Array<object>): T | undefined {
+  get(items: object[]): T | undefined {
     return this.#items.get(this.compositeKeyFor(items));
   }
 
-  set(items: Array<object>, value: any): string {
+  set(items: object[], value: any): string {
     const key = this.compositeKeyFor(items);
     this.#items.set(key, value);
     return key;
   }
 
-  compositeKeyFor(items: Array<object>) {
+  compositeKeyFor(items: object[]) {
     return items.map((i) => this.keyFor(i)).join(",");
   }
 
@@ -82,7 +82,7 @@ interface PendingModelInfo {
 }
 
 export function createChecker(program: Program) {
-  let templateInstantiation: Array<Type> = [];
+  let templateInstantiation: Type[] = [];
   let instantiatingTemplate: Node | undefined;
   let currentSymbolId = 0;
   const symbolLinks = new Map<number, SymbolLinks>();
@@ -194,7 +194,7 @@ export function createChecker(program: Program) {
   }
 
   function checkTemplateParameterDeclaration(node: TemplateParameterDeclarationNode): Type {
-    const parentNode = <ModelStatementNode>node.parent!;
+    const parentNode = node.parent! as ModelStatementNode;
 
     if (instantiatingTemplate === parentNode) {
       const index = parentNode.templateParameters.findIndex((v) => v === node);
@@ -279,7 +279,7 @@ export function createChecker(program: Program) {
    * twice at the same time, or if template parameters from more than one template
    * are ever in scope at once.
    */
-  function instantiateTemplate(templateNode: ModelStatementNode, args: Array<Type>): ModelType {
+  function instantiateTemplate(templateNode: ModelStatementNode, args: Type[]): ModelType {
     const symbolLinks = getSymbolLinks(templateNode.symbol!);
     const cached = symbolLinks.instantiations!.get(args) as ModelType;
     if (cached) {
@@ -291,7 +291,7 @@ export function createChecker(program: Program) {
     templateInstantiation = args;
     instantiatingTemplate = templateNode;
     // this cast is invalid once we support templatized `model =`.
-    const type = <ModelType>getTypeForNode(templateNode);
+    const type = getTypeForNode(templateNode) as ModelType;
 
     symbolLinks.instantiations!.set(args, type);
 
@@ -309,7 +309,7 @@ export function createChecker(program: Program) {
     });
   }
 
-  function allModelTypes(types: Array<Type>): types is Array<ModelType> {
+  function allModelTypes(types: Type[]): types is ModelType[] {
     return types.every((t) => t.kind === "Model");
   }
 
@@ -439,7 +439,7 @@ export function createChecker(program: Program) {
       name: node.id.sv,
       namespace: getParentNamespaceType(node),
       node: node,
-      parameters: <ModelType>getTypeForNode(node.parameters),
+      parameters: getTypeForNode(node.parameters) as ModelType,
       returnType: getTypeForNode(node.returnType),
     });
   }
@@ -651,7 +651,7 @@ export function createChecker(program: Program) {
     const properties = new Map();
     for (const prop of node.properties!) {
       if ("id" in prop) {
-        const propType = <ModelTypeProperty>getTypeForNode(prop);
+        const propType = getTypeForNode(prop) as ModelTypeProperty;
         properties.set(propType.name, propType);
       } else {
         // spread property

packages/adl/compiler/diagnostics.ts

@@ -44,7 +44,7 @@ export type WriteLine = (text?: string) => void;
 export type ErrorHandler = (
   message: Message | string,
   target: DiagnosticTarget,
-  args?: Array<string | number>
+  args?: (string | number)[]
 ) => void;
 
 export const throwOnError: ErrorHandler = throwDiagnostic;
@@ -52,7 +52,7 @@ export const throwOnError: ErrorHandler = throwDiagnostic;
 export function throwDiagnostic(
   message: Message | string,
   target: DiagnosticTarget,
-  args?: Array<string | number>
+  args?: (string | number)[]
 ): never {
   throw new DiagnosticError([createDiagnostic(message, target, args)]);
 }
@@ -60,7 +60,7 @@ export function throwDiagnostic(
 export function createDiagnostic(
   message: Message | string,
   target: DiagnosticTarget,
-  args?: Array<string | number>
+  args?: (string | number)[]
 ): Diagnostic {
   let location: SourceLocation;
   let locationError: Error | undefined;
@@ -109,7 +109,7 @@ export function formatDiagnostic(diagnostic: Diagnostic) {
 }
 
 export function createSourceFile(text: string, path: string): SourceFile {
-  let lineStarts: Array<number> | undefined = undefined;
+  let lineStarts: number[] | undefined = undefined;
 
   return {
     text,
@@ -176,7 +176,7 @@ export function createSourceFile(text: string, path: string): SourceFile {
    * is the bitwise complement of the index where value would need to be inserted
    * to keep the array sorted.
    */
-  function binarySearch(array: ReadonlyArray<number>, value: number) {
+  function binarySearch(array: readonly number[], value: number) {
     let low = 0;
     let high = array.length - 1;
     while (low <= high) {
@@ -318,7 +318,7 @@ export function compilerAssert(
   }
 }
 
-function format(text: string, args?: Array<string | number>): [string, Error?] {
+function format(text: string, args?: (string | number)[]): [string, Error?] {
   let error: Error | undefined;
   const message = text.replace(/{(\d+)}/g, (_match, indexString: string) => {
     const index = Number(indexString);

packages/adl/compiler/parser.ts

@@ -1102,7 +1102,7 @@ function visitNode<T>(cb: NodeCb<T>, node: Types.Node | undefined): T | undefine
   return node && cb(node);
 }
 
-function visitEach<T>(cb: NodeCb<T>, nodes: Array<Types.Node> | undefined): T | undefined {
+function visitEach<T>(cb: NodeCb<T>, nodes: Types.Node[] | undefined): T | undefined {
   if (!nodes) {
     return;
   }

packages/adl/compiler/program.ts

@@ -22,7 +22,7 @@ import {
 export interface Program {
   compilerOptions: CompilerOptions;
   globalNamespace: NamespaceStatementNode;
-  sourceFiles: Array<ADLScriptNode>;
+  sourceFiles: ADLScriptNode[];
   typeCache: MultiKeyMap<Type>;
   literalTypes: Map<string | number | boolean, LiteralType>;
   host: CompilerHost;
@@ -97,7 +97,7 @@ export async function createProgram(
   }
 
   function executeModelDecorators(type: ModelType) {
-    const stmt = <ModelStatementNode>(type.templateNode || type.node);
+    const stmt = (type.templateNode || type.node) as ModelStatementNode;
 
     for (const dec of stmt.decorators) {
       executeDecorator(dec, program, type);
@@ -131,7 +131,7 @@ export async function createProgram(
 
     const decName = dec.target.sv;
     const args = dec.arguments.map((a) => toJSON(checker.getTypeForNode(a)));
-    const decBinding = <DecoratorSymbol>program.globalNamespace.locals!.get(decName);
+    const decBinding = program.globalNamespace.locals!.get(decName) as DecoratorSymbol;
     if (!decBinding) {
       throwDiagnostic(`Can't find decorator ${decName}`, dec);
     }

packages/adl/compiler/scanner.ts

@@ -409,7 +409,7 @@ export function createScanner(source: string | SourceFile, onError = throwOnErro
     return false;
   }
 
-  function error(msg: Message, args?: Array<string | number>) {
+  function error(msg: Message, args?: (string | number)[]) {
     onError(msg, { file, pos: tokenPosition, end: position }, args);
   }
 

packages/adl/compiler/types.ts

@@ -8,7 +8,7 @@ import { Message as MessageImpl } from "./messages.js";
 export interface BaseType {
   kind: string;
   node?: Node;
-  instantiationParameters?: Array<Type>;
+  instantiationParameters?: Type[];
 }
 
 export type Type =
@@ -36,8 +36,8 @@ export interface ModelType extends BaseType {
   node: ModelStatementNode | ModelExpressionNode | IntersectionExpressionNode;
   namespace?: NamespaceType;
   properties: Map<string, ModelTypeProperty>;
-  baseModels: Array<ModelType>;
-  templateArguments?: Array<Type>;
+  baseModels: ModelType[];
+  templateArguments?: Type[];
   templateNode?: Node;
   assignmentType?: Type;
 }
@@ -101,13 +101,13 @@ export interface ArrayType extends BaseType {
 export interface TupleType extends BaseType {
   kind: "Tuple";
   node: TupleExpressionNode;
-  values: Array<Type>;
+  values: Type[];
 }
 
 export interface UnionType extends BaseType {
   kind: "Union";
   node: UnionExpressionNode;
-  options: Array<Type>;
+  options: Type[];
 }
 
 export interface TemplateParameterType extends BaseType {
@@ -122,7 +122,7 @@ export interface DecoratorSymbol {
   kind: "decorator";
   path: string;
   name: string;
-  value: (...args: Array<any>) => any;
+  value: (...args: any[]) => any;
 }
 
 export interface TypeSymbol {
@@ -188,10 +188,10 @@ export type Node =
 
 export interface ADLScriptNode extends BaseNode {
   kind: SyntaxKind.ADLScript;
-  statements: Array<Statement>;
-  models: Array<ModelType>;
+  statements: Statement[];
+  models: ModelType[];
   file: SourceFile;
-  interfaces: Array<NamespaceType>;
+  interfaces: NamespaceType[];
   inScopeNamespaces: NamespaceStatementNode[]; // namespaces that declarations in this file belong to
   namespaces: NamespaceStatementNode[]; // list of namespaces in this file (initialized during binding)
   locals: SymbolTable;
@@ -237,7 +237,7 @@ export interface NamedImportNode extends BaseNode {
 export interface DecoratorExpressionNode extends BaseNode {
   kind: SyntaxKind.DecoratorExpression;
   target: IdentifierNode | MemberExpressionNode;
-  arguments: Array<Expression>;
+  arguments: Expression[];
 }
 
 export type Expression =
@@ -264,10 +264,10 @@ export interface MemberExpressionNode extends BaseNode {
 export interface NamespaceStatementNode extends BaseNode, DeclarationNode {
   kind: SyntaxKind.NamespaceStatement;
   name: IdentifierNode;
-  statements?: Array<Statement> | NamespaceStatementNode;
+  statements?: Statement[] | NamespaceStatementNode;
   locals?: SymbolTable;
   exports?: SymbolTable;
-  decorators: Array<DecoratorExpressionNode>;
+  decorators: DecoratorExpressionNode[];
 }
 
 export interface UsingStatementNode extends BaseNode {
@@ -280,23 +280,23 @@ export interface OperationStatementNode extends BaseNode, DeclarationNode {
   id: IdentifierNode;
   parameters: ModelExpressionNode;
   returnType: Expression;
-  decorators: Array<DecoratorExpressionNode>;
+  decorators: DecoratorExpressionNode[];
 }
 
 export interface ModelStatementNode extends BaseNode, DeclarationNode {
   kind: SyntaxKind.ModelStatement;
   id: IdentifierNode;
-  properties?: Array<ModelPropertyNode | ModelSpreadPropertyNode>;
-  heritage: Array<ReferenceExpression>;
+  properties?: (ModelPropertyNode | ModelSpreadPropertyNode)[];
+  heritage: ReferenceExpression[];
   assignment?: Expression;
-  templateParameters: Array<TemplateParameterDeclarationNode>;
+  templateParameters: TemplateParameterDeclarationNode[];
   locals?: SymbolTable;
-  decorators: Array<DecoratorExpressionNode>;
+  decorators: DecoratorExpressionNode[];
 }
 
 export interface ModelExpressionNode extends BaseNode {
   kind: SyntaxKind.ModelExpression;
-  properties: Array<ModelPropertyNode | ModelSpreadPropertyNode>;
+  properties: (ModelPropertyNode | ModelSpreadPropertyNode)[];
 }
 
 export interface ArrayExpressionNode extends BaseNode {
@@ -305,14 +305,14 @@ export interface ArrayExpressionNode extends BaseNode {
 }
 export interface TupleExpressionNode extends BaseNode {
   kind: SyntaxKind.TupleExpression;
-  values: Array<Expression>;
+  values: Expression[];
 }
 
 export interface ModelPropertyNode extends BaseNode {
   kind: SyntaxKind.ModelProperty;
   id: IdentifierNode | StringLiteralNode;
   value: Expression;
-  decorators: Array<DecoratorExpressionNode>;
+  decorators: DecoratorExpressionNode[];
   optional: boolean;
 }
 
@@ -340,18 +340,18 @@ export interface BooleanLiteralNode extends BaseNode {
 
 export interface UnionExpressionNode extends BaseNode {
   kind: SyntaxKind.UnionExpression;
-  options: Array<Expression>;
+  options: Expression[];
 }
 
 export interface IntersectionExpressionNode extends BaseNode {
   kind: SyntaxKind.IntersectionExpression;
-  options: Array<Expression>;
+  options: Expression[];
 }
 
 export interface TypeReferenceNode extends BaseNode {
   kind: SyntaxKind.TypeReference;
   target: ReferenceExpression;
-  arguments: Array<Expression>;
+  arguments: Expression[];
 }
 
 export interface TemplateParameterDeclarationNode extends BaseNode {
@@ -399,7 +399,7 @@ export interface SourceFile {
    * per line, in order of lines, and each entry represents the offset in UTF-16
    * code units from the start of the document to the beginning of the line.
    */
-  getLineStarts(): ReadonlyArray<number>;
+  getLineStarts(): readonly number[];
 
   /**
    * Converts a one-dimensional position in the document (measured in UTF-16

packages/adl/compiler/util.ts

@@ -16,7 +16,7 @@ function getVersion(): string {
 
 export function reportDuplicateSymbols(symbols: SymbolTable) {
   let reported = new Set<Sym>();
-  let diagnostics = new Array<Diagnostic>();
+  let diagnostics: Diagnostic[] = [];
 
   for (const symbol of symbols.duplicates) {
     report(symbol);

packages/adl/test/test-scanner.ts

@@ -15,9 +15,9 @@ import { LineAndCharacter } from "../compiler/types.js";
 
 type TokenEntry = [Token, string?, number?, LineAndCharacter?];
 
-function tokens(text: string, onError = throwOnError): Array<TokenEntry> {
+function tokens(text: string, onError = throwOnError): TokenEntry[] {
   const scanner = createScanner(text, onError);
-  const result: Array<TokenEntry> = [];
+  const result: TokenEntry[] = [];
   do {
     const token = scanner.scan();
     assert.strictEqual(token, scanner.token);
@@ -36,7 +36,7 @@ function tokens(text: string, onError = throwOnError): Array<TokenEntry> {
   return result;
 }
 
-function verify(tokens: Array<TokenEntry>, expecting: Array<TokenEntry>) {
+function verify(tokens: TokenEntry[], expecting: TokenEntry[]) {
   for (const [
     index,
     [expectedToken, expectedText, expectedPosition, expectedLineAndCharacter],