Use lazy initializations for decorators and type parameters in parser (#554)

Author: MaxGraey

src/parser.ts

@@ -164,8 +164,8 @@ export class Parser extends DiagnosticEmitter {
         this.skipStatement(tn);
         continue;
       }
-      if (!decorators) decorators = [];
-      decorators.push(decorator);
+      if (!decorators) decorators = [decorator];
+      else decorators.push(decorator);
     }
 
     // check modifiers
@@ -454,7 +454,7 @@ export class Parser extends DiagnosticEmitter {
     } else if (token == Token.IDENTIFIER) {
       let first = Node.createSimpleTypeName(tn.readIdentifier(), tn.range());
       let current = first;
-      let parameters = new Array<TypeNode>();
+      let parameters: TypeNode[] | null = null;
       let nullable = false;
 
       // Identifier ('.' Identifier)+
@@ -477,7 +477,8 @@ export class Parser extends DiagnosticEmitter {
         do {
           let parameter = this.parseType(tn, true, suppressErrors);
           if (!parameter) return null;
-          parameters.push(<TypeNode>parameter);
+          if (!parameters) parameters = [<TypeNode>parameter];
+          else parameters.push(<TypeNode>parameter);
         } while (tn.skip(Token.COMMA));
         if (!tn.skip(Token.GREATERTHAN)) {
           if (!suppressErrors) {
@@ -503,8 +504,7 @@ export class Parser extends DiagnosticEmitter {
           return null;
         }
       }
-      type = Node.createType(first, parameters, nullable, tn.range(startPos, tn.pos));
-
+      type = Node.createType(first, parameters || [], nullable, tn.range(startPos, tn.pos));
     } else {
       if (!suppressErrors) {
         this.error(
@@ -939,7 +939,7 @@ export class Parser extends DiagnosticEmitter {
 
     // at '<': TypeParameter (',' TypeParameter)* '>'
 
-    var typeParameters = new Array<TypeParameterNode>();
+    var typeParameters: TypeParameterNode[] | null = null;
     var seenOptional = false;
     while (!tn.skip(Token.GREATERTHAN)) {
       let typeParameter = this.parseTypeParameter(tn);
@@ -953,7 +953,8 @@ export class Parser extends DiagnosticEmitter {
         );
         typeParameter.defaultType = null;
       }
-      typeParameters.push(<TypeParameterNode>typeParameter);
+      if (!typeParameters) typeParameters = [ typeParameter ];
+      else typeParameters.push(typeParameter);
       if (!tn.skip(Token.COMMA)) {
         if (tn.skip(Token.GREATERTHAN)) {
           break;
@@ -966,7 +967,7 @@ export class Parser extends DiagnosticEmitter {
         }
       }
     }
-    if (typeParameters.length === 0) {
+    if (!(typeParameters && typeParameters.length)) {
       this.error(
         DiagnosticCode.Type_parameter_list_cannot_be_empty,
         tn.range()
@@ -1532,8 +1533,8 @@ export class Parser extends DiagnosticEmitter {
         let type = this.parseType(tn);
         if (!type) return null;
         if (!isInterface) {
-          if (!implementsTypes) implementsTypes = [];
-          implementsTypes.push(<TypeNode>type);
+          if (!implementsTypes) implementsTypes = [<TypeNode>type];
+          else implementsTypes.push(<TypeNode>type);
         }
       } while (tn.skip(Token.COMMA));
     }
@@ -1636,14 +1637,15 @@ export class Parser extends DiagnosticEmitter {
     var startPos = tn.pos;
     var isInterface = parent.kind == NodeKind.INTERFACEDECLARATION;
 
-    var decorators = new Array<DecoratorNode>();
+    var decorators: DecoratorNode[] | null = null;
     if (tn.skip(Token.AT)) {
       do {
         let decorator = this.parseDecorator(tn);
         if (!decorator) break;
-        decorators.push(<DecoratorNode>decorator);
+        if (!decorators) decorators = [<DecoratorNode>decorator];
+        else decorators.push(<DecoratorNode>decorator);
       } while (tn.skip(Token.AT));
-      if (isInterface) {
+      if (decorators && isInterface) {
         this.error(
           DiagnosticCode.Decorators_are_not_valid_here,
           Range.join(decorators[0].range, decorators[decorators.length - 1].range)
@@ -2064,11 +2066,11 @@ export class Parser extends DiagnosticEmitter {
     return null;
   }
 
-  parseIndexSignatureDeclaration(tn: Tokenizer, decorators: DecoratorNode[]): IndexSignatureDeclaration | null {
+  parseIndexSignatureDeclaration(tn: Tokenizer, decorators: DecoratorNode[] | null): IndexSignatureDeclaration | null {
 
     // at: '[': 'key' ':' Type ']' ':' Type
 
-    if (decorators.length) {
+    if (decorators && decorators.length) {
       this.error(
         DiagnosticCode.Decorators_are_not_valid_here,
         Range.join(decorators[0].range, decorators[decorators.length - 1].range)
@@ -3410,7 +3412,7 @@ export class Parser extends DiagnosticEmitter {
 
     var state = tn.mark();
     if (!tn.skip(Token.LESSTHAN)) return null;
-    var typeArguments = new Array<CommonTypeNode>();
+    var typeArguments: CommonTypeNode[] | null = null;
     do {
       if (tn.peek() === Token.GREATERTHAN) {
         break;
@@ -3420,7 +3422,8 @@ export class Parser extends DiagnosticEmitter {
         tn.reset(state);
         return null;
       }
-      typeArguments.push(type);
+      if (!typeArguments) typeArguments = [ type ];
+      else typeArguments.push(type);
     } while (tn.skip(Token.COMMA));
     if (tn.skip(Token.GREATERTHAN) && tn.skip(Token.OPENPAREN)) {
       return typeArguments;