Fix TsLint errors (#7)

Author: anush6898

src/AST/ASTExpression.ts

@@ -6,6 +6,8 @@
 import ASTNode from './ASTNode';
 
 // ASTExpression is the base node for expressions.
+
+// tslint:disable-next-line:no-empty-interface
 interface ASTExpression extends ASTNode {}
 
 export default ASTExpression;

src/AST/ASTStatement.ts

@@ -5,10 +5,10 @@
 
 import ASTNode from './ASTNode';
 
-/**
- * ASTStatement represents a statement.
- * All nodes in a Program are statements.
- */
+// ASTStatement represents a statement.
+// All nodes in a Program are statements.
+
+// tslint:disable-next-line:no-empty-interface
 interface ASTStatement extends ASTNode {}
 
 export default ASTStatement;

src/AST/Program.ts

@@ -7,7 +7,7 @@ import ASTNode from './ASTNode';
 
 // Program is the root node of the abstract syntax tree representing the JSL input.
 class Program implements ASTNode {
-  statements: Array<ASTNode>;
+  statements: ASTNode[];
 
   constructor() {
     this.statements = [];

src/JSLEvaluator.ts

@@ -24,7 +24,7 @@ class JSLEvaluator {
       case ASTIntegerLiteral:
         return this.evaluateIntegerExpression(node as ASTIntegerLiteral);
       default:
-        throw `${node.tokenLiteral()} node evaluation not supported`;
+        throw new Error(`${node.tokenLiteral()} node evaluation not supported`);
     }
   }
 
@@ -39,7 +39,7 @@ class JSLEvaluator {
   private evaluateExpressionStatement(statement: ASTExpressionStatement, json: any): any {
     const expression = statement.expression;
     if (!expression) {
-      throw `Expression: ${statement.toString()} not found`;
+      throw new Error(`Expression: ${statement.toString()} not found`);
     }
 
     return this.evaluate(json, expression);
@@ -49,12 +49,12 @@ class JSLEvaluator {
 
   private evaluateSelectExpression(expression: ASTSelectExpression, json: any): any {
     if (typeof json !== 'object') {
-      throw `Invalid nested key sequence ${expression.key}`;
+      throw new Error(`Invalid nested key sequence ${expression.key}`);
     }
 
     const key: string = expression.key;
     if (!json.hasOwnProperty(key)) {
-      throw `Key not found in the json: ${expression.key}`;
+      throw new Error(`Key not found in the json: ${expression.key}`);
     }
 
     return json[key];
@@ -64,7 +64,7 @@ class JSLEvaluator {
     const left = expression.left;
     const index = expression.index;
     if (!left || !index) {
-      throw `Expression: ${expression.toString()} not found`;
+      throw new Error(`Expression: ${expression.toString()} not found`);
     }
 
     const arr: any = this.evaluate(json, left);
@@ -73,7 +73,7 @@ class JSLEvaluator {
       return arr[idx];
     }
 
-    throw `cannot subscript at ${expression.toString()}[${idx}]`;
+    throw new Error(`cannot subscript at ${expression.toString()}[${idx}]`);
   }
 
   private evaluateIntegerExpression(expression: ASTIntegerLiteral): number {

src/Lexer.ts

@@ -7,7 +7,7 @@ import { dot, int, ident, lbracket, rbracket, eof, Token } from './tokens';
 
 // Lexer represents the lexical analyzer for JSON Selector Language
 class Lexer {
-  private input: Array<string> = [];
+  private input: string[] = [];
   private position: number = 0;
   private readPosition: number = 0;
   private currentCharacter: string = '';
@@ -73,27 +73,27 @@ class Lexer {
 
   // readIdentifier returns a token with an identifier as the literal
   private readIdentifier(): Token {
-    let startIdx = this.position;
+    const startIdx = this.position;
     while (this.isIdent(this.currentCharacter)) {
       this.readChar();
     }
 
-    const identfier: Array<string> = this.input.slice(startIdx, this.position);
-    const identStr: string = identfier.join('');
+    const identifier: string[] = this.input.slice(startIdx, this.position);
+    const identStr: string = identifier.join('');
 
     return { type: ident, literal: identStr };
   }
 
   // readNumber returns a token with a numeric literal
   private readNumber(): string {
-    let startIdx = this.position;
+    const startIdx = this.position;
     while (this.isNumeric(this.currentCharacter)) {
       this.readChar();
     }
 
-    const number: Array<string> = this.input.slice(startIdx, this.position);
+    const num: string[] = this.input.slice(startIdx, this.position);
 
-    return number.join('');
+    return num.join('');
   }
 
   // isIdent returns true if a character is not one of the other tokens

src/Parser.ts

@@ -25,7 +25,7 @@ type InfixParser = (arg?: ASTExpression) => ASTExpression | undefined;
 
 class Parser {
   private lexer: Lexer;
-  private errors: Array<string> = [];
+  private errors: string[] = [];
 
   private curToken!: Token;
   private peekToken!: Token;
@@ -53,7 +53,7 @@ class Parser {
   }
 
   parseProgram(): Program {
-    let program = new Program();
+    const program = new Program();
 
     while (!this.isCurToken(eof)) {
       const stmt = this.parseStatement();
@@ -107,7 +107,7 @@ class Parser {
     );
   }
 
-  private noPrefixParseFuncErr(type: String): void {
+  private noPrefixParseFuncErr(type: string): void {
     this.errors.push(`prefix parse func for ${type} not found`);
   }
 
@@ -178,7 +178,7 @@ class Parser {
       return;
     }
 
-    let idx = this.parseExpression(Precedence.lowest);
+    const idx = this.parseExpression(Precedence.lowest);
     if (!this.expectPeek(rbracket)) {
       return;
     }

src/__tests__/JSLEvaluator.test.ts

@@ -83,14 +83,14 @@ describe('JSLEvaluator', () => {
       fail();
     }
 
-    const testCase = 'Key not found in the json: width';
+    const testCase = new Error('Key not found in the json: width');
     expect(returnedError).toEqual(testCase);
   });
 
   it('tests with invalid jsl input', () => {
     const input = '..[]';
     const json = { data: [{}, {}, { width: 200 }] };
-    let returnedError: Array<string> = [];
+    let returnedError: string[] = [];
 
     try {
       const program = JSL.compile(input);