From 363559f9296200f076aed3d6873372dfc8430221 Mon Sep 17 00:00:00 2001
From: jiangkaiwen <jiangkaiwen2@huawei.com>
Date: Tue, 4 Apr 2023 15:25:25 +0800
Subject: [PATCH] Fix codecheck warnings of master branch

Issue:I6SY11

Signed-off-by: jiangkaiwen <jiangkaiwen2@huawei.com>
Change-Id: I6436d017b053cc00063bc80b4803cd399659e6b7
---
 testTs/instype/recordexport.ts                |   6 +-
 testTs/instype/recordthis.ts                  |   8 +-
 ts2panda/src/addVariable2Scope.ts             |  12 +-
 ts2panda/src/assemblyDumper.ts                |  36 +--
 ts2panda/src/astutils.ts                      |   4 +-
 ts2panda/src/base/bcGenUtil.ts                | 114 +++----
 ts2panda/src/base/builtIn.ts                  |  16 +-
 ts2panda/src/base/iterator.ts                 |  22 +-
 ts2panda/src/base/lexEnv.ts                   |   2 +-
 ts2panda/src/base/literal.ts                  |  14 +-
 ts2panda/src/base/lreference.ts               |  38 +--
 ts2panda/src/base/properties.ts               | 106 +++---
 ts2panda/src/base/typeSystem.ts               | 114 +++----
 ts2panda/src/base/util.ts                     |  92 +++---
 ts2panda/src/base/vregisterCache.ts           |  44 +--
 ts2panda/src/cmdOptions.ts                    |  14 +-
 ts2panda/src/compiler.ts                      | 225 ++++++-------
 ts2panda/src/compilerDriver.ts                |  48 +--
 ts2panda/src/compilerStatistics.ts            |  49 +--
 ts2panda/src/compilerUtils.ts                 |  38 +--
 ts2panda/src/debuginfo.ts                     |  42 +--
 ts2panda/src/ecmaModule.ts                    |  50 +--
 .../src/expression/arrayLiteralExpression.ts  |  16 +-
 ts2panda/src/expression/bigIntLiteral.ts      |   2 +-
 ts2panda/src/expression/callExpression.ts     |  14 +-
 .../expression/compileCommaListExpression.ts  |   2 +-
 .../src/expression/memberAccessExpression.ts  |  15 +-
 ts2panda/src/expression/metaProperty.ts       |   4 +-
 ts2panda/src/expression/newExpression.ts      |   2 +-
 ts2panda/src/expression/numericLiteral.ts     |   6 +-
 .../src/expression/objectLiteralExpression.ts |  60 ++--
 .../src/expression/parenthesizedExpression.ts |   4 +-
 ts2panda/src/expression/regularExpression.ts  |  10 +-
 ts2panda/src/expression/stringLiteral.ts      |   2 +-
 ts2panda/src/expression/templateExpression.ts |  16 +-
 ts2panda/src/expression/yieldExpression.ts    |   8 +-
 ts2panda/src/function/asyncFunctionBuilder.ts |  22 +-
 .../function/asyncGeneratorFunctionBuilder.ts |  36 +--
 ts2panda/src/function/functionBuilder.ts      |   8 +-
 .../src/function/generatorFunctionBuilder.ts  |  60 ++--
 ts2panda/src/hoisting.ts                      |  26 +-
 ts2panda/src/index.ts                         |  32 +-
 ts2panda/src/jshelpers.d.ts                   |   3 +-
 ts2panda/src/lexenv.ts                        |  12 +-
 ts2panda/src/lexicalBinder.ts                 |  18 +-
 ts2panda/src/log.ts                           |   8 +-
 ts2panda/src/modules.ts                       |  20 +-
 ts2panda/src/pandagen.ts                      | 306 +++++++++---------
 ts2panda/src/recorder.ts                      |  94 +++---
 ts2panda/src/regAllocator.ts                  |  18 +-
 ts2panda/src/scope.ts                         |  84 ++---
 ts2panda/src/statement/classStatement.ts      | 124 +++----
 ts2panda/src/statement/forOfStatement.ts      |  16 +-
 ts2panda/src/statement/labelTarget.ts         |  32 +-
 ts2panda/src/statement/loopStatement.ts       |  12 +-
 ts2panda/src/statement/returnStatement.ts     |  26 +-
 ts2panda/src/statement/switchStatement.ts     |   2 +-
 ts2panda/src/statement/tryStatement.ts        |  73 ++---
 ts2panda/src/strictMode.ts                    |  12 +-
 ts2panda/src/syntaxCheckHelper.ts             |  22 +-
 ts2panda/src/syntaxChecker.ts                 | 286 ++++++++--------
 ts2panda/src/syntaxCheckerForStrcitMode.ts    |  42 +--
 ts2panda/src/ts2panda.ts                      |  47 +--
 ts2panda/src/typeChecker.ts                   |  74 ++---
 ts2panda/src/typeRecorder.ts                  |  80 ++---
 ts2panda/src/variable.ts                      |  56 ++--
 ts2panda/templates/irnodes.ts.erb             |   8 +-
 ts2panda/tests/builtIns.test.ts               |   2 +-
 ts2panda/tests/expression/binary.test.ts      |   2 +-
 ts2panda/tests/expression/conditions.test.ts  |   2 +-
 .../expression/functionExpression.test.ts     |  42 +--
 .../tests/expression/prefixOperations.test.ts |   6 +-
 .../tests/expression/propertyAccess.test.ts   |  10 +-
 .../expression/templateExpression.test.ts     |   6 +-
 ts2panda/tests/lexenv.test.ts                 |  44 +--
 ts2panda/tests/regAllocator.test.ts           |   4 +-
 .../statements/functionDeclaration.test.ts    |  20 +-
 .../statements/variableDeclaration.test.ts    |   2 +-
 ts2panda/tests/strictmode/function.js         |   6 +-
 ts2panda/tests/strictmode/function_nest1.js   |   4 +-
 ts2panda/tests/strictmode/function_nest2.js   |   6 +-
 ts2panda/tests/strictmode/strictmode.test.ts  |   4 +-
 ts2panda/tests/types/class.test.ts            |   8 +-
 ts2panda/tests/types/class/class_abstract.ts  |   6 +-
 .../tests/types/class/class_implements.ts     |   6 +-
 ts2panda/tests/types/function.test.ts         |   2 +-
 .../types/function/function_multi_para.ts     |   2 +-
 ts2panda/tests/types/typeUtils.ts             |  14 +-
 ts2panda/tests/utils/base.ts                  |  20 +-
 ts2panda/tests/utils/example_asthelper.ts     |   6 +-
 .../tests/watch_expression/addWatch.test.ts   |  12 +-
 ts2panda/tools/astPrinter.ts                  |  23 +-
 ts2panda/webpack.config.js                    |   2 +-
 93 files changed, 1613 insertions(+), 1562 deletions(-)

diff --git a/testTs/instype/recordexport.ts b/testTs/instype/recordexport.ts
index 5328134355..105a82b844 100644
--- a/testTs/instype/recordexport.ts
+++ b/testTs/instype/recordexport.ts
@@ -1,4 +1,4 @@
-export default function hello(str: string) {
+export default function hello(str: string): string {
     return str;
 }
 
@@ -9,11 +9,11 @@ export let d: string = "world";
 
 export class Calculator{}
 
-export function add(x: number, y: number) {
+export function add(x: number, y: number): number {
     return x + y;
 }
 
-export function minus(x: number, y: number) {
+export function minus(x: number, y: number): number {
     return x - y;
 }
 
diff --git a/testTs/instype/recordthis.ts b/testTs/instype/recordthis.ts
index c032ae27be..7ddec1decf 100644
--- a/testTs/instype/recordthis.ts
+++ b/testTs/instype/recordthis.ts
@@ -19,7 +19,7 @@ class A {
     get getName(): string {
         return this.name;
     }
-    get getId() {
+    get getId(): number {
         return this.id;
     }
     set setName(name: string) {
@@ -37,13 +37,13 @@ class A {
     }
     static a: number = 1;
     a: number = 2;
-    static stest() {
+    static stest(): void {
         console.log(this.a);
     }
-    test() {
+    test(): void {
         console.log(this.a);
     }
-    testwiththis(this: A) {
+    testwiththis(this: A): void {
         console.log(this.a);
     }
 }
diff --git a/ts2panda/src/addVariable2Scope.ts b/ts2panda/src/addVariable2Scope.ts
index 0f64f618bd..b35414a189 100644
--- a/ts2panda/src/addVariable2Scope.ts
+++ b/ts2panda/src/addVariable2Scope.ts
@@ -42,7 +42,7 @@ import {
     Variable
 } from "./variable";
 
-function setVariableOrParameterType(node: ts.Node, v: Variable | undefined) {
+function setVariableOrParameterType(node: ts.Node, v: Variable | undefined): void {
     if (v) {
         let typeIndex = TypeRecorder.getInstance().tryGetVariable2Type(ts.getOriginalNode(node));
         if (typeIndex === PrimitiveType.ANY) {
@@ -52,14 +52,14 @@ function setVariableOrParameterType(node: ts.Node, v: Variable | undefined) {
     }
 }
 
-function setClassOrFunctionType(node: ts.Node, v: Variable | undefined) {
+function setClassOrFunctionType(node: ts.Node, v: Variable | undefined): void {
     if (v) {
         let typeIndex = TypeRecorder.getInstance().tryGetTypeIndex(ts.getOriginalNode(node));
         v.setTypeIndex(typeIndex);
     }
 }
 
-function setTypeIndex(node: ts.Node, v: Variable | undefined, isClassOrFunction: boolean) {
+function setTypeIndex(node: ts.Node, v: Variable | undefined, isClassOrFunction: boolean): void {
     if (isClassOrFunction) {
         setClassOrFunctionType(node, v);
     } else {
@@ -72,7 +72,7 @@ function addInnerArgs(node: ts.Node, scope: VariableScope, enableTypeRecord: boo
     scope.addParameter(MandatoryFuncObj, VarDeclarationKind.CONST, -1);
     // the second argument for newTarget
 
-    if (node.kind == ts.SyntaxKind.ArrowFunction) {
+    if (node.kind === ts.SyntaxKind.ArrowFunction) {
         scope.addParameter("0newTarget", VarDeclarationKind.CONST, -1);
         scope.addParameter("0this", VarDeclarationKind.CONST, 0);
     } else {
@@ -107,7 +107,7 @@ function addInnerArgs(node: ts.Node, scope: VariableScope, enableTypeRecord: boo
     }
 }
 
-export function addVariableToScope(recorder: Recorder, enableTypeRecord: boolean) {
+export function addVariableToScope(recorder: Recorder, enableTypeRecord: boolean): void {
     let scopeMap = recorder.getScopeMap();
     let hoistMap = recorder.getHoistMap();
 
@@ -210,7 +210,7 @@ function addParameters(node: ts.FunctionLikeDeclaration, scope: VariableScope, e
     }
 }
 
-function addPatternParamterElements(pattern: ts.BindingPattern, scope: VariableScope) {
+function addPatternParamterElements(pattern: ts.BindingPattern, scope: VariableScope): void {
     let name: string = '';
     pattern.elements.forEach(bindingElement => {
         if (ts.isOmittedExpression(bindingElement)) {
diff --git a/ts2panda/src/assemblyDumper.ts b/ts2panda/src/assemblyDumper.ts
index 6b2fc9d793..88ad92d34a 100644
--- a/ts2panda/src/assemblyDumper.ts
+++ b/ts2panda/src/assemblyDumper.ts
@@ -41,7 +41,7 @@ export class IntrinsicInfo {
 }
 
 export class AssemblyDumper {
-    private labels: Map<number, string> // Label.id : Label string name
+    private labels: Map<number, string>; // Label.id : Label string name
     private labelId: number;
     private pg: PandaGen;
     readonly labelPrefix = "LABEL_";
@@ -62,7 +62,7 @@ export class AssemblyDumper {
 
     writeFunctionHeader(): void {
         let parametersCount = this.pg.getParametersCount();
-        this.output += ".function any " + this.pg.internalName + "("
+        this.output += ".function any " + this.pg.internalName + "(";
         for (let i = 0; i < parametersCount; ++i) {
             this.output += "any a" + i.toString();
             if (i !== parametersCount - 1) {
@@ -96,31 +96,31 @@ export class AssemblyDumper {
                 continue;
             }
 
-            this.output += "\t"
+            this.output += "\t";
             this.output += node.getMnemonic() + " ";
             let operands = node.operands;
             let formats = node.getFormats();
-            var outputRangeVregNum = getRangeExplicitVregNums(node);
+            let outputRangeVregNum = getRangeExplicitVregNums(node);
             for (let j = 0; j < operands.length; ++j) {
-                if (outputRangeVregNum == 0) {
+                if (outputRangeVregNum === 0) {
                     break;
                 }
                 let format = formats[0];
                 let kind = format[j][0];
                 let op = operands[j];
 
-                if (kind == OperandKind.Imm) {
+                if (kind === OperandKind.Imm) {
                     let imm = <Imm>op;
                     this.output += imm.value.toString();
-                } else if (kind == OperandKind.Id) {
+                } else if (kind === OperandKind.Id) {
                     this.output += op;
-                } else if (kind == OperandKind.StringId) {
+                } else if (kind === OperandKind.StringId) {
                     let escapedOp = op.toString().replace(/\\/g, "\\\\").replace(/\t/g, "\\t")
                         .replace(/\n/g, "\\n").replace(/\"/g, "\\\"")
                     this.output += "\"" + escapedOp + "\"";
-                } else if (kind == OperandKind.DstVReg
-                    || kind == OperandKind.SrcDstVReg
-                    || kind == OperandKind.SrcVReg) {
+                } else if (kind === OperandKind.DstVReg ||
+                    kind === OperandKind.SrcDstVReg ||
+                    kind === OperandKind.SrcVReg) {
                     let v = <VReg>op;
                     if (v.num < 0) {
                         throw Error("invalid register, please check your insn!\n");
@@ -131,7 +131,7 @@ export class AssemblyDumper {
                         outputRangeVregNum--;
                         continue;
                     }
-                } else if (kind == OperandKind.Label) {
+                } else if (kind === OperandKind.Label) {
                     this.output += this.getLabelName(<Label>op);
                 } else {
                     throw new Error("Unexpected OperandKind");
@@ -150,7 +150,7 @@ export class AssemblyDumper {
 
     writeFunctionCatchTable(): void {
         let catchTables = generateCatchTables(this.pg.getCatchMap());
-        if (catchTables.length == 0) {
+        if (catchTables.length === 0) {
             return;
         }
 
@@ -159,10 +159,10 @@ export class AssemblyDumper {
             let catchBeginLabel = catchTable.getCatchBeginLabel();
             let labelPairs = catchTable.getLabelPairs();
             labelPairs.forEach((labelPair) => {
-                this.output += ".catchall " + this.getLabelName(labelPair.getBeginLabel())
-                    + ", " + this.getLabelName(labelPair.getEndLabel())
-                    + ", " + this.getLabelName(catchBeginLabel)
-                    + "\n"
+                this.output += ".catchall " + this.getLabelName(labelPair.getBeginLabel()) +
+                    ", " + this.getLabelName(labelPair.getEndLabel()) +
+                    ", " + this.getLabelName(catchBeginLabel) +
+                    "\n";
             });
         });
     }
@@ -195,6 +195,6 @@ export class AssemblyDumper {
     static dumpHeader(): void {
         let out = { str: "" };
         AssemblyDumper.writeLanguageTag(out);
-        console.log(out.str)
+        console.log(out.str);
     }
 }
diff --git a/ts2panda/src/astutils.ts b/ts2panda/src/astutils.ts
index de080462b7..324b857788 100644
--- a/ts2panda/src/astutils.ts
+++ b/ts2panda/src/astutils.ts
@@ -17,7 +17,7 @@ import * as ts from "typescript";
 import { VarDeclarationKind } from "./variable";
 
 export function getVarDeclarationKind(decl: ts.VariableDeclaration): VarDeclarationKind {
-    if (decl.parent.kind == ts.SyntaxKind.VariableDeclarationList) {
+    if (decl.parent.kind === ts.SyntaxKind.VariableDeclarationList) {
         let declList = <ts.VariableDeclarationList>decl.parent;
         if ((declList.flags & ts.NodeFlags.Let) != 0) {
             return VarDeclarationKind.LET;
@@ -26,7 +26,7 @@ export function getVarDeclarationKind(decl: ts.VariableDeclaration): VarDeclarat
         } else {
             return VarDeclarationKind.VAR;
         }
-    } else if (decl.parent.kind == ts.SyntaxKind.CatchClause) {
+    } else if (decl.parent.kind === ts.SyntaxKind.CatchClause) {
         return VarDeclarationKind.LET;
     } else {
         throw new Error("VariableDeclaration inside " + ts.SyntaxKind[decl.parent] + " is not implemented");
diff --git a/ts2panda/src/base/bcGenUtil.ts b/ts2panda/src/base/bcGenUtil.ts
index 22ae1ca7db..ec036c6ff6 100644
--- a/ts2panda/src/base/bcGenUtil.ts
+++ b/ts2panda/src/base/bcGenUtil.ts
@@ -161,24 +161,24 @@ export function throwException(): IRNode {
     return new Throw();
 }
 
-export function throwConstAssignment(name: VReg) {
+export function throwConstAssignment(name: VReg): IRNode {
     return new ThrowConstassignment(name);
 }
 
-export function throwUndefinedIfHole(name: string) {
+export function throwUndefinedIfHole(name: string): IRNode {
     return new ThrowUndefinedifholewithname(name);
 }
 
-export function throwThrowNotExists() {
+export function throwThrowNotExists(): IRNode {
     return new ThrowNotexists();
 }
 
-export function throwDeleteSuperProperty() {
+export function throwDeleteSuperProperty(): IRNode {
     return new ThrowDeletesuperproperty();
 }
 
-export function newLexicalEnv(numVars: number, scopeInfoId: string | undefined) {
-    if (scopeInfoId == undefined) {
+export function newLexicalEnv(numVars: number, scopeInfoId: string | undefined): IRNode {
+    if (scopeInfoId === undefined) {
         return numVars <= MAX_INT8 ? new Newlexenv(new Imm(numVars)) :
                                      new WideNewlexenv(new Imm(numVars));
     }
@@ -186,54 +186,54 @@ export function newLexicalEnv(numVars: number, scopeInfoId: string | undefined)
                                  new WideNewlexenvwithname(new Imm(numVars), scopeInfoId);
 }
 
-export function popLexicalEnv() {
+export function popLexicalEnv(): IRNode {
     return new Poplexenv();
 }
 
-export function loadLexicalVar(level: number, slot: number) {
+export function loadLexicalVar(level: number, slot: number): IRNode {
     if ((level > MAX_INT8) || (slot > MAX_INT8)) {
         return new WideLdlexvar(new Imm(level), new Imm(slot));
     }
     return new Ldlexvar(new Imm(level), new Imm(slot));
 }
 
-export function storeLexicalVar(level: number, slot: number) {
+export function storeLexicalVar(level: number, slot: number): IRNode {
     if ((level > MAX_INT8) || (slot > MAX_INT8)) {
         return new WideStlexvar(new Imm(level), new Imm(slot));
     }
     return new Stlexvar(new Imm(level), new Imm(slot));
 }
 
-export function tryLoadGlobalByName(key: string) {
+export function tryLoadGlobalByName(key: string): IRNode {
     return new Tryldglobalbyname(new Imm(0), key);
 }
 
-export function tryStoreGlobalByName(key: string) {
+export function tryStoreGlobalByName(key: string): IRNode {
     return new Trystglobalbyname(new Imm(0), key);
 }
 
-export function loadGlobalVar(name: string) {
+export function loadGlobalVar(name: string): IRNode {
     return new Ldglobalvar(new Imm(0), name);
 }
 
-export function storeGlobalVar(name: string) {
+export function storeGlobalVar(name: string): IRNode {
     return new Stglobalvar(new Imm(0), name);
 }
 
-export function loadObjByName(key: string) {
+export function loadObjByName(key: string): IRNode {
     return new Ldobjbyname(new Imm(0), key);
 }
 
-export function storeObjByName(obj: VReg, key: string) {
+export function storeObjByName(obj: VReg, key: string): IRNode {
     return new Stobjbyname(new Imm(0), key, obj);
 }
 
-export function loadObjByIndex(index: number) {
+export function loadObjByIndex(index: number): IRNode {
     return index <= MAX_INT16 ? new Ldobjbyindex(new Imm(0), new Imm(index)) :
                                 new WideLdobjbyindex(new Imm(index));
 }
 
-export function storeObjByIndex(obj: VReg, index: number) {
+export function storeObjByIndex(obj: VReg, index: number): IRNode {
     return index <= MAX_INT16 ? new Stobjbyindex(new Imm(0), obj, new Imm(index)) :
                                 new WideStobjbyindex(obj, new Imm(index));
 }
@@ -251,21 +251,21 @@ export function storeOwnByName(obj: VReg, key: string, nameSetting: boolean): IR
                          new Stownbyname(new Imm(0), key, obj);
 }
 
-export function storeOwnByIndex(obj: VReg, index: number) {
+export function storeOwnByIndex(obj: VReg, index: number): IRNode {
     return index <= MAX_INT16 ? new Stownbyindex(new Imm(0), obj, new Imm(index)) :
                                 new WideStownbyindex(obj, new Imm(index));
 }
 
-export function storeOwnByValue(obj: VReg, value: VReg, nameSetting: boolean) {
+export function storeOwnByValue(obj: VReg, value: VReg, nameSetting: boolean): IRNode {
     return nameSetting ? new Stownbyvaluewithnameset(new Imm(0), obj, value) :
                          new Stownbyvalue(new Imm(0), obj, value);
 }
 
-export function throwIfSuperNotCorrectCall(num: number) {
+export function throwIfSuperNotCorrectCall(num: number): IRNode {
     return new ThrowIfsupernotcorrectcall(new Imm(num));
 }
 
-export function call(args: VReg[], passThis: boolean) {
+export function call(args: VReg[], passThis: boolean): IRNode {
     let length = args.length;
     let insn: IRNode;
     if (!passThis) {
@@ -293,7 +293,7 @@ export function call(args: VReg[], passThis: boolean) {
     return insn;
 }
 
-function callThis(args: Array<VReg>) {
+function callThis(args: Array<VReg>): IRNode {
     let insn: IRNode;
     let thisReg: VReg = args[0];
     let length = args.length;
@@ -323,105 +323,105 @@ function callThis(args: Array<VReg>) {
     return insn;
 }
 
-export function newObject(args: VReg[]) {
+export function newObject(args: VReg[]): IRNode {
     let length = args.length;
     return length <= MAX_INT8 ? new Newobjrange(new Imm(0), new Imm(length), args) :
                                 new WideNewobjrange(new Imm(length), args);
 }
 
-export function getPropIterator() {
+export function getPropIterator(): IRNode {
     return new Getpropiterator();
 }
 
-export function getNextPropName(iter: VReg) {
+export function getNextPropName(iter: VReg): IRNode {
     return new Getnextpropname(iter);
 }
 
-export function returnUndefined() {
+export function returnUndefined(): IRNode {
     return new Returnundefined();
 }
 
-export function createEmptyObject() {
+export function createEmptyObject(): IRNode {
     return new Createemptyobject();
 }
 
-export function createObjectWithBuffer(bufferId: string) {
+export function createObjectWithBuffer(bufferId: string): IRNode {
     return new Createobjectwithbuffer(new Imm(0), bufferId);
 }
 
-export function setObjectWithProto(proto: VReg) {
+export function setObjectWithProto(proto: VReg): IRNode {
     return new Setobjectwithproto(new Imm(0), proto);
 }
 
-export function copyDataProperties(dstObj: VReg) {
+export function copyDataProperties(dstObj: VReg): IRNode {
     return new Copydataproperties(dstObj);
 }
 
-export function defineGetterSetterByValue(obj: VReg, name: VReg, getter: VReg, setter: VReg) {
+export function defineGetterSetterByValue(obj: VReg, name: VReg, getter: VReg, setter: VReg): IRNode {
     return new Definegettersetterbyvalue(obj, name, getter, setter);
 }
 
-export function createEmptyArray() {
+export function createEmptyArray(): IRNode {
     return new Createemptyarray(new Imm(0));
 }
 
-export function createArrayWithBuffer(bufferId: string) {
+export function createArrayWithBuffer(bufferId: string): IRNode {
     return new Createarraywithbuffer(new Imm(0), bufferId);
 }
 
-export function storeArraySpread(array: VReg, index: VReg) {
+export function storeArraySpread(array: VReg, index: VReg): IRNode {
     return new Starrayspread(array, index);
 }
 
-export function defineClassWithBuffer(id: string, litId: string, parameterLength: number, base: VReg) {
+export function defineClassWithBuffer(id: string, litId: string, parameterLength: number, base: VReg): IRNode {
     return new Defineclasswithbuffer(new Imm(0), id, litId, new Imm(parameterLength), base);
 }
 
-export function createObjectWithExcludedKeys(obj: VReg, args: VReg[]) {
+export function createObjectWithExcludedKeys(obj: VReg, args: VReg[]): IRNode {
     let followedArgs = args.length - 1;
     return followedArgs <= MAX_INT8 ? new Createobjectwithexcludedkeys(new Imm(followedArgs), obj, args) :
                                       new WideCreateobjectwithexcludedkeys(new Imm(followedArgs), obj, args);
 }
 
-export function throwObjectNonCoercible() {
+export function throwObjectNonCoercible(): IRNode {
     return new ThrowPatternnoncoercible();
 }
 
-export function throwIfNotObject(v: VReg) {
+export function throwIfNotObject(v: VReg): IRNode {
     return new ThrowIfnotobject(v);
 }
 
-export function getIterator() {
+export function getIterator(): IRNode {
     return new Getiterator(new Imm(0));
 }
 
-export function closeIterator(iter: VReg) {
+export function closeIterator(iter: VReg): IRNode {
     return new Closeiterator(new Imm(0), iter);
 }
 
-export function superCall(num: number, args: Array<VReg>) {
+export function superCall(num: number, args: Array<VReg>): IRNode {
     return num <= MAX_INT8 ? new Supercallthisrange(new Imm(0), new Imm(num), args) :
                              new WideSupercallthisrange(new Imm(num), args);
 }
 
-export function superCallInArrow(num: number, args: Array<VReg>) {
+export function superCallInArrow(num: number, args: Array<VReg>): IRNode {
     return num <= MAX_INT8 ? new Supercallarrowrange(new Imm(0), new Imm(num), args) :
                              new WideSupercallarrowrange(new Imm(num), args);
 }
 
-export function superCallSpread(vs: VReg) {
+export function superCallSpread(vs: VReg): IRNode {
     return new Supercallspread(new Imm(0), vs);
 }
 
-export function ldSuperByName(key: string) {
+export function ldSuperByName(key: string): IRNode {
     return new Ldsuperbyname(new Imm(0), key); // obj is in acc
 }
 
-export function stSuperByName(obj: VReg, key: string) {
+export function stSuperByName(obj: VReg, key: string): IRNode {
     return new Stsuperbyname(new Imm(0), key, obj);
 }
 
-export function stSuperByValue(obj: VReg, prop: VReg) {
+export function stSuperByValue(obj: VReg, prop: VReg): IRNode {
     return new Stsuperbyvalue(new Imm(0), obj, prop);
 }
 
@@ -429,11 +429,11 @@ export function ldSuperByValue(obj: VReg): IRNode {
     return new Ldsuperbyvalue(new Imm(0), obj); // prop is in acc
 }
 
-export function loadLocalModuleVariable(index: number) {
+export function loadLocalModuleVariable(index: number): IRNode {
     return index <= MAX_INT8 ? new Ldlocalmodulevar(new Imm(index)) : new WideLdlocalmodulevar(new Imm(index));
 }
 
-export function loadExternalModuleVariable(index: number) {
+export function loadExternalModuleVariable(index: number): IRNode {
     return index <= MAX_INT8 ? new Ldexternalmodulevar(new Imm(index)) : new WideLdexternalmodulevar(new Imm(index));
 }
 
@@ -442,40 +442,40 @@ export function dynamicImport() {
     return new Dynamicimport();
 }
 
-export function storeModuleVariable(index: number) {
+export function storeModuleVariable(index: number): IRNode {
     return index <= MAX_INT8 ? new Stmodulevar(new Imm(index)) : new WideStmodulevar(new Imm(index));
 }
 
-export function getModuleNamespace(moduleRequestIdx: number) {
+export function getModuleNamespace(moduleRequestIdx: number): IRNode {
     return moduleRequestIdx <= MAX_INT8 ? new Getmodulenamespace(new Imm(moduleRequestIdx)) :
                                           new WideGetmodulenamespace(new Imm(moduleRequestIdx));
 }
 
-export function defineFunc(name: string, paramLength: number) {
+export function defineFunc(name: string, paramLength: number): IRNode {
     return new Definefunc(new Imm(0), name, new Imm(paramLength));
 }
 
-export function defineMethod(name: string, paramLength: number) {
+export function defineMethod(name: string, paramLength: number): IRNode {
     return new Definemethod(new Imm(0), name, new Imm(paramLength));
 }
 
-export function isTrue() {
+export function isTrue(): IRNode {
     return new Istrue();
 }
 
-export function isFalse() {
+export function isFalse(): IRNode {
     return new Isfalse();
 }
 
-export function createRegExpWithLiteral(pattern: string, flags: number) {
+export function createRegExpWithLiteral(pattern: string, flags: number): IRNode {
     return new Createregexpwithliteral(new Imm(0), pattern, new Imm(flags));
 }
 
-export function stLetOrClassToGlobalRecord(name: string) {
+export function stLetOrClassToGlobalRecord(name: string): IRNode {
     return new Sttoglobalrecord(new Imm(0), name);
 }
 
-export function stConstToGlobalRecord(name: string) {
+export function stConstToGlobalRecord(name: string): IRNode {
     return new Stconsttoglobalrecord(new Imm(0), name);
 }
 
diff --git a/ts2panda/src/base/builtIn.ts b/ts2panda/src/base/builtIn.ts
index 62c716d9fb..3ff3d99120 100644
--- a/ts2panda/src/base/builtIn.ts
+++ b/ts2panda/src/base/builtIn.ts
@@ -39,7 +39,7 @@ export function expandHole(pandaGen: PandaGen): IRNode[] {
 }
 
 export function expandNaN(pandaGen: PandaGen): IRNode[] {
-    let vreg = getVregisterCache(pandaGen, CacheList.NaN);
+    let vreg = getVregisterCache(pandaGen, CacheList.NAN);
     return [
         new Ldnan(),
         new Sta(vreg)
@@ -47,7 +47,7 @@ export function expandNaN(pandaGen: PandaGen): IRNode[] {
 }
 
 export function expandInfinity(pandaGen: PandaGen): IRNode[] {
-    let vreg = getVregisterCache(pandaGen, CacheList.Infinity);
+    let vreg = getVregisterCache(pandaGen, CacheList.INFINITY);
     return [
         new Ldinfinity(),
         new Sta(vreg)
@@ -55,7 +55,7 @@ export function expandInfinity(pandaGen: PandaGen): IRNode[] {
 }
 
 export function expandGlobal(pandaGen: PandaGen): IRNode[] {
-    let vreg = getVregisterCache(pandaGen, CacheList.Global);
+    let vreg = getVregisterCache(pandaGen, CacheList.GLOBAL);
     return [
         new Ldglobal(),
         new Sta(vreg)
@@ -63,7 +63,7 @@ export function expandGlobal(pandaGen: PandaGen): IRNode[] {
 }
 
 export function expandUndefined(pandaGen: PandaGen): IRNode[] {
-    let vreg = getVregisterCache(pandaGen, CacheList.undefined);
+    let vreg = getVregisterCache(pandaGen, CacheList.UNDEFINED);
     return [
         new Ldundefined(),
         new Sta(vreg)
@@ -71,7 +71,7 @@ export function expandUndefined(pandaGen: PandaGen): IRNode[] {
 }
 
 export function expandSymbol(pandaGen: PandaGen): IRNode[] {
-    let vreg = getVregisterCache(pandaGen, CacheList.Symbol);
+    let vreg = getVregisterCache(pandaGen, CacheList.SYMBOL);
     return [
         new Ldsymbol(),
         new Sta(vreg)
@@ -79,7 +79,7 @@ export function expandSymbol(pandaGen: PandaGen): IRNode[] {
 }
 
 export function expandNull(pandaGen: PandaGen): IRNode[] {
-    let vreg = getVregisterCache(pandaGen, CacheList.Null);
+    let vreg = getVregisterCache(pandaGen, CacheList.NULL);
     return [
         new Ldnull(),
         new Sta(vreg)
@@ -87,7 +87,7 @@ export function expandNull(pandaGen: PandaGen): IRNode[] {
 }
 
 export function expandTrue(pandaGen: PandaGen): IRNode[] {
-    let vreg = getVregisterCache(pandaGen, CacheList.True);
+    let vreg = getVregisterCache(pandaGen, CacheList.TRUE);
     return [
         new Ldtrue(),
         new Sta(vreg)
@@ -95,7 +95,7 @@ export function expandTrue(pandaGen: PandaGen): IRNode[] {
 }
 
 export function expandFalse(pandaGen: PandaGen): IRNode[] {
-    let vreg = getVregisterCache(pandaGen, CacheList.False);
+    let vreg = getVregisterCache(pandaGen, CacheList.FALSE);
     return [
         new Ldfalse(),
         new Sta(vreg)
diff --git a/ts2panda/src/base/iterator.ts b/ts2panda/src/base/iterator.ts
index 1eed765d3f..0051954d7a 100644
--- a/ts2panda/src/base/iterator.ts
+++ b/ts2panda/src/base/iterator.ts
@@ -50,12 +50,12 @@ export class Iterator {
         }
     }
 
-    getIterator() {
+    getIterator(): void {
         let pandaGen = this.pandaGen;
         let iterator = this.iterRecord.iterator;
 
         // get iterator
-        this.kind == IteratorType.Normal ? pandaGen.getIterator(this.node) : pandaGen.getAsyncIterator(this.node);
+        this.kind === IteratorType.Normal ? pandaGen.getIterator(this.node) : pandaGen.getAsyncIterator(this.node);
         pandaGen.storeAccumulator(this.node, iterator);
 
         // get the next method
@@ -67,7 +67,7 @@ export class Iterator {
         return this.iterRecord.nextMethod;
     }
 
-    getMethod(id: string) {
+    getMethod(id: string): void {
         this.pandaGen.loadObjProperty(this.node, this.iterRecord.iterator, id);
         this.pandaGen.storeAccumulator(this.node, this.iterRecord.nextMethod);
     }
@@ -78,28 +78,28 @@ export class Iterator {
      *      throw TypeError
      *  }
      */
-    callNext(iterResult: VReg) {
+    callNext(iterResult: VReg): void {
         this.pandaGen.call(this.node, [this.iterRecord.nextMethod, this.iterRecord.iterator], true);
         this.pandaGen.storeAccumulator(this.node, iterResult);
     }
 
-    callMethodwithValue(value: VReg) {
+    callMethodwithValue(value: VReg): void {
         this.pandaGen.call(this.node, [this.iterRecord.nextMethod, this.iterRecord.iterator, value], true);
     }
 
-    iteratorComplete(iterResult: VReg) {
+    iteratorComplete(iterResult: VReg): void {
         this.pandaGen.loadObjProperty(this.node, iterResult, "done");
         this.pandaGen.storeAccumulator(this.node, this.iterDone);
     }
 
-    iteratorValue(iterResult: VReg) {
+    iteratorValue(iterResult: VReg): void {
         this.pandaGen.loadObjProperty(this.node, iterResult, "value");
         this.pandaGen.storeAccumulator(this.node, this.iterValue);
     }
 
-    close() {
+    close(): void {
         let pg = this.pandaGen;
-        if (this.kind == IteratorType.Normal) {
+        if (this.kind === IteratorType.Normal) {
             pg.closeIterator(this.node, this.iterRecord.iterator);
             return;
         }
@@ -164,11 +164,11 @@ export class Iterator {
         pg.freeTemps(completion, res, exception)
     }
 
-    getCurrentValue() {
+    getCurrentValue(): VReg {
         return this.iterValue;
     }
 
-    getCurrrentDone() {
+    getCurrrentDone(): VReg {
         return this.iterDone;
     }
 }
\ No newline at end of file
diff --git a/ts2panda/src/base/lexEnv.ts b/ts2panda/src/base/lexEnv.ts
index 5393dbd8b1..b54da6154d 100644
--- a/ts2panda/src/base/lexEnv.ts
+++ b/ts2panda/src/base/lexEnv.ts
@@ -36,7 +36,7 @@ function createLexEnv(pandaGen: PandaGen, scope: VariableScope): IRNode[] {
 
     insns.push(
         newLexicalEnv(lexEnvVars, scopeInfoId),
-        storeAccumulator(getVregisterCache(pandaGen, CacheList.LexEnv))
+        storeAccumulator(getVregisterCache(pandaGen, CacheList.LEXENV))
     );
 
     return insns;
diff --git a/ts2panda/src/base/literal.ts b/ts2panda/src/base/literal.ts
index 2cfb246236..fe7cc6f916 100644
--- a/ts2panda/src/base/literal.ts
+++ b/ts2panda/src/base/literal.ts
@@ -39,11 +39,11 @@ export class Literal {
         this.v = v;
     }
 
-    getTag() {
+    getTag(): LiteralTag {
         return this.t;
     }
 
-    getValue() {
+    getValue(): any {
         return this.v;
     }
 }
@@ -58,22 +58,22 @@ export class LiteralBuffer {
         this.lb.push(...literals);
     }
 
-    getLiterals() {
+    getLiterals(): Literal[] {
         return this.lb;
     }
 
-    isEmpty() {
-        return this.lb.length == 0;
+    isEmpty(): boolean {
+        return this.lb.length === 0;
     }
 
-    getLiteral(index: number) {
+    getLiteral(index: number): Literal {
         if (index >= this.lb.length || this.lb.length <=0) {
         return ;
         }
         return this.lb[index];
     }
 
-    setKey(key: string) {
+    setKey(key: string): void {
         this.k = key;
     }
 }
diff --git a/ts2panda/src/base/lreference.ts b/ts2panda/src/base/lreference.ts
index f51dc6f774..bf637b4ff8 100644
--- a/ts2panda/src/base/lreference.ts
+++ b/ts2panda/src/base/lreference.ts
@@ -26,7 +26,7 @@ import { Scope } from "../scope";
 import { VarDeclarationKind, Variable } from "../variable";
 import { isBindingOrAssignmentPattern } from "./util";
 
-enum ReferenceKind { MemberAccess, LocalOrGlobal, Destructuring };
+enum ReferenceKind { MEMBER_ACCESS, LOCAL_OR_GLOBAL, DESTRUCTURING };
 export class LReference {
     private node: ts.Node;
     private compiler: Compiler;
@@ -49,20 +49,20 @@ export class LReference {
         this.isDeclaration = isDeclaration;
         this.refKind = refKind;
 
-        if (refKind == ReferenceKind.Destructuring) {
+        if (refKind === ReferenceKind.DESTRUCTURING) {
             this.destructuringTarget = <ts.BindingOrAssignmentPattern>node;
-        } else if (refKind == ReferenceKind.LocalOrGlobal) {
+        } else if (refKind === ReferenceKind.LOCAL_OR_GLOBAL) {
             this.variable = variable!;
-        } else if (refKind == ReferenceKind.MemberAccess) {
+        } else if (refKind === ReferenceKind.MEMBER_ACCESS) {
             this.obj = compiler.getPandaGen().getTemp();
             this.prop = compiler.getPandaGen().getTemp();
         }
     }
 
-    getValue() {
+    getValue(): void {
         let pandaGen = this.compiler.getPandaGen();
         switch (this.refKind) {
-            case ReferenceKind.MemberAccess:
+            case ReferenceKind.MEMBER_ACCESS:
                 let prop: VReg | number | string;
                 if (this.propLiteral === undefined) {
                     prop = <VReg>this.prop!;
@@ -71,21 +71,21 @@ export class LReference {
                 }
                 pandaGen.loadObjProperty(this.node, <VReg>this.obj, prop);
                 return;
-            case ReferenceKind.LocalOrGlobal:
+            case ReferenceKind.LOCAL_OR_GLOBAL:
                 this.compiler.loadTarget(this.node, this.variable!);
                 return;
-            case ReferenceKind.Destructuring:
+            case ReferenceKind.DESTRUCTURING:
                 throw new Error("Destructuring target can't be loaded");
             default:
-                throw new Error("Invalid LReference kind to GetValue")
+                throw new Error("Invalid LReference kind to GetValue");
         }
     }
 
-    setValue() {
+    setValue(): void {
         let pandaGen = this.compiler.getPandaGen();
         switch (this.refKind) {
-            case ReferenceKind.MemberAccess: {
-                let prop: VReg | number | string
+            case ReferenceKind.MEMBER_ACCESS: {
+                let prop: VReg | number | string;
                 if (this.propLiteral === undefined) {
                     prop = <VReg>this.prop!;
                 } else {
@@ -102,18 +102,18 @@ export class LReference {
                 pandaGen.freeTemps(...[<VReg>this.obj, <VReg>this.prop]);
                 return;
             }
-            case ReferenceKind.LocalOrGlobal:
+            case ReferenceKind.LOCAL_OR_GLOBAL:
                 this.compiler.storeTarget(this.node, this.variable!, this.isDeclaration);
                 return;
-            case ReferenceKind.Destructuring:
+            case ReferenceKind.DESTRUCTURING:
                 compileDestructuring(<ts.BindingOrAssignmentPattern>this.destructuringTarget, pandaGen, this.compiler);
                 return;
             default:
-                throw new Error("Invalid LReference kind to SetValue")
+                throw new Error("Invalid LReference kind to SetValue");
         }
     }
 
-    setObjectAndProperty(pandaGen: PandaGen, obj: VReg, prop: VReg | number | string) {
+    setObjectAndProperty(pandaGen: PandaGen, obj: VReg, prop: VReg | number | string): void {
         if (!jshelpers.isSuperProperty(this.node)) {
             pandaGen.moveVreg(this.node, <VReg>this.obj, obj);
         }
@@ -149,11 +149,11 @@ export class LReference {
                 }
             }
 
-            return new LReference(realNode, compiler, isDeclaration, ReferenceKind.LocalOrGlobal, variable);
+            return new LReference(realNode, compiler, isDeclaration, ReferenceKind.LOCAL_OR_GLOBAL, variable);
         }
 
         if (ts.isPropertyAccessExpression(realNode) || ts.isElementAccessExpression(realNode)) {
-            let lref = new LReference(realNode, compiler, false, ReferenceKind.MemberAccess, undefined);
+            let lref = new LReference(realNode, compiler, false, ReferenceKind.MEMBER_ACCESS, undefined);
             let objReg = pandaGen.getTemp();
             let propReg = pandaGen.getTemp();
             let { obj: object, prop: property } = getObjAndProp(realNode, objReg, propReg, compiler);
@@ -171,7 +171,7 @@ export class LReference {
         }
 
         if (isBindingOrAssignmentPattern(realNode)) {
-            return new LReference(realNode, compiler, isDeclaration, ReferenceKind.Destructuring, undefined);
+            return new LReference(realNode, compiler, isDeclaration, ReferenceKind.DESTRUCTURING, undefined);
         }
 
         throw new DiagnosticError(
diff --git a/ts2panda/src/base/properties.ts b/ts2panda/src/base/properties.ts
index cd11acf7e4..7a6e448d57 100644
--- a/ts2panda/src/base/properties.ts
+++ b/ts2panda/src/base/properties.ts
@@ -18,12 +18,12 @@ import { isValidIndex } from "../expression/memberAccessExpression";
 import * as jshelpers from "../jshelpers";
 
 export enum PropertyKind {
-    Variable,
-    Constant,
-    Computed, // Property with computed value (execution time).
-    Prototype,
-    Accessor,
-    Spread
+    VARIABLE,
+    CONSTANT,
+    COMPUTED, // Property with computed value (execution time).
+    PROTOTYPE,
+    ACCESSOR,
+    SPREAD
 }
 
 export class Property {
@@ -42,73 +42,73 @@ export class Property {
         }
     }
 
-    setCompiled() {
+    setCompiled(): void {
         this.compiled = true;
     }
 
-    setRedeclared() {
+    setRedeclared(): void {
         this.redeclared = true;
     }
 
-    isCompiled() {
+    isCompiled(): boolean {
         return this.compiled;
     }
 
-    isRedeclared() {
+    isRedeclared(): boolean {
         return this.redeclared;
     }
 
-    getName() {
-        if (typeof (this.name) == 'undefined') {
+    getName(): string | number | ts.ComputedPropertyName {
+        if (typeof (this.name) === 'undefined') {
             throw new Error("this property doesn't have a name");
         }
         return this.name;
     }
 
-    getKind() {
+    getKind(): PropertyKind {
         return this.propKind;
     }
 
-    getValue() {
-        if (this.propKind == PropertyKind.Accessor) {
-            throw new Error("Accessor doesn't have valueNode")
+    getValue(): ts.Node {
+        if (this.propKind === PropertyKind.ACCESSOR) {
+            throw new Error("Accessor doesn't have valueNode");
         }
         return this.valueNode!;
     }
 
-    getGetter() {
+    getGetter(): ts.GetAccessorDeclaration {
         return this.getterNode;
     }
 
-    getSetter() {
+    getSetter(): ts.SetAccessorDeclaration {
         return this.setterNode;
     }
 
-    setValue(valueNode: ts.Node) {
+    setValue(valueNode: ts.Node): void {
         this.valueNode = valueNode;
         this.getterNode = undefined;
         this.setterNode = undefined;
     }
 
-    setGetter(getter: ts.GetAccessorDeclaration) {
-        if (this.propKind != PropertyKind.Accessor) {
+    setGetter(getter: ts.GetAccessorDeclaration): void {
+        if (this.propKind != PropertyKind.ACCESSOR) {
             this.valueNode = undefined;
             this.setterNode = undefined;
-            this.propKind = PropertyKind.Accessor;
+            this.propKind = PropertyKind.ACCESSOR;
         }
         this.getterNode = getter;
     }
 
-    setSetter(setter: ts.SetAccessorDeclaration) {
-        if (this.propKind != PropertyKind.Accessor) {
+    setSetter(setter: ts.SetAccessorDeclaration): void {
+        if (this.propKind != PropertyKind.ACCESSOR) {
             this.valueNode = undefined;
             this.getterNode = undefined;
-            this.propKind = PropertyKind.Accessor;
+            this.propKind = PropertyKind.ACCESSOR;
         }
         this.setterNode = setter;
     }
 
-    setKind(propKind: PropertyKind) {
+    setKind(propKind: PropertyKind): void {
         this.propKind = propKind;
     }
 }
@@ -122,15 +122,15 @@ export function generatePropertyFromExpr(expr: ts.ObjectLiteralExpression): Prop
     expr.properties.forEach(property => {
         switch (property.kind) {
             case ts.SyntaxKind.PropertyAssignment: {
-                if (property.name.kind == ts.SyntaxKind.ComputedPropertyName) {
-                    defineProperty(property.name, property, PropertyKind.Computed, properties, namedPropertyMap);
+                if (property.name.kind === ts.SyntaxKind.ComputedPropertyName) {
+                    defineProperty(property.name, property, PropertyKind.COMPUTED, properties, namedPropertyMap);
                     break;
                 }
 
                 let propName: number | string = <number | string>getPropName(property.name);
-                if (propName == "__proto__") {
+                if (propName === "__proto__") {
                     if (!hasProto) {
-                        defineProperty(propName, property.initializer, PropertyKind.Prototype, properties, namedPropertyMap);
+                        defineProperty(propName, property.initializer, PropertyKind.PROTOTYPE, properties, namedPropertyMap);
                         hasProto = true;
                         break;
                     } else {
@@ -139,38 +139,38 @@ export function generatePropertyFromExpr(expr: ts.ObjectLiteralExpression): Prop
                 }
 
                 if (isConstantExpr(property.initializer)) {
-                    defineProperty(propName, property.initializer, PropertyKind.Constant, properties, namedPropertyMap);
+                    defineProperty(propName, property.initializer, PropertyKind.CONSTANT, properties, namedPropertyMap);
                 } else {
-                    defineProperty(propName, property.initializer, PropertyKind.Variable, properties, namedPropertyMap);
+                    defineProperty(propName, property.initializer, PropertyKind.VARIABLE, properties, namedPropertyMap);
                 }
                 break;
             }
             case ts.SyntaxKind.ShorthandPropertyAssignment: {
                 // ShorthandProperty's name always be Identifier
                 let propName = jshelpers.getTextOfIdentifierOrLiteral(property.name);
-                defineProperty(propName, property.name, PropertyKind.Variable, properties, namedPropertyMap);
+                defineProperty(propName, property.name, PropertyKind.VARIABLE, properties, namedPropertyMap);
                 break;
             }
             case ts.SyntaxKind.SpreadAssignment: {
-                defineProperty(undefined, property.expression, PropertyKind.Spread, properties, namedPropertyMap);
+                defineProperty(undefined, property.expression, PropertyKind.SPREAD, properties, namedPropertyMap);
                 break;
             }
             case ts.SyntaxKind.MethodDeclaration: {
                 let propName = getPropName(property.name);
-                if (typeof (propName) == 'string' || typeof (propName) == 'number') {
-                    defineProperty(propName, property, PropertyKind.Variable, properties, namedPropertyMap);
+                if (typeof (propName) === 'string' || typeof (propName) === 'number') {
+                    defineProperty(propName, property, PropertyKind.VARIABLE, properties, namedPropertyMap);
                 } else {
-                    defineProperty(propName, property, PropertyKind.Computed, properties, namedPropertyMap);
+                    defineProperty(propName, property, PropertyKind.COMPUTED, properties, namedPropertyMap);
                 }
                 break;
             }
             case ts.SyntaxKind.GetAccessor:
             case ts.SyntaxKind.SetAccessor: {
                 let propName = getPropName(property.name);
-                if (typeof (propName) == 'string' || typeof (propName) == 'number') {
-                    defineProperty(propName, property, PropertyKind.Accessor, properties, namedPropertyMap);
+                if (typeof (propName) === 'string' || typeof (propName) === 'number') {
+                    defineProperty(propName, property, PropertyKind.ACCESSOR, properties, namedPropertyMap);
                 } else {
-                    defineProperty(propName, property, PropertyKind.Computed, properties, namedPropertyMap);
+                    defineProperty(propName, property, PropertyKind.COMPUTED, properties, namedPropertyMap);
                 }
                 break;
             }
@@ -187,8 +187,8 @@ function defineProperty(
     propValue: ts.Node,
     propKind: PropertyKind,
     properties: Property[],
-    namedPropertyMap: Map<string, number>) {
-    if (propKind == PropertyKind.Computed || propKind == PropertyKind.Spread) {
+    namedPropertyMap: Map<string, number>): void {
+    if (propKind === PropertyKind.COMPUTED || propKind === PropertyKind.SPREAD) {
         let prop = new Property(propKind, <ts.ComputedPropertyName | undefined>propName);
         prop.setValue(propValue);
         properties.push(prop);
@@ -199,9 +199,9 @@ function defineProperty(
         if (namedPropertyMap.has(name_str)) {
             let prevProp = properties[namedPropertyMap.get(name_str)!];
 
-            if ((prevProp.getKind() == PropertyKind.Accessor || prevProp.getKind() == PropertyKind.Constant)
-                && (propKind == PropertyKind.Accessor || propKind == PropertyKind.Constant)) {
-                if (propKind == PropertyKind.Accessor) {
+            if ((prevProp.getKind() === PropertyKind.ACCESSOR || prevProp.getKind() === PropertyKind.CONSTANT) &&
+                (propKind === PropertyKind.ACCESSOR || propKind === PropertyKind.CONSTANT)) {
+                if (propKind === PropertyKind.ACCESSOR) {
                     if (ts.isGetAccessorDeclaration(propValue)) {
                         prevProp!.setGetter(propValue);
                     } else if (ts.isSetAccessorDeclaration(propValue)) {
@@ -209,7 +209,7 @@ function defineProperty(
                     }
                 } else {
                     prevProp!.setValue(propValue);
-                    prevProp!.setKind(PropertyKind.Constant);
+                    prevProp!.setKind(PropertyKind.CONSTANT);
                 }
                 return;
             }
@@ -218,7 +218,7 @@ function defineProperty(
         }
 
         namedPropertyMap.set(name_str, properties.length);
-        if (propKind == PropertyKind.Accessor) {
+        if (propKind === PropertyKind.ACCESSOR) {
             if (ts.isGetAccessorDeclaration(propValue)) {
                 prop.setGetter(propValue);
             } else if (ts.isSetAccessorDeclaration(propValue)) {
@@ -244,28 +244,28 @@ export function isConstantExpr(node: ts.Node): boolean {
     }
 }
 
-export function propertyKeyAsString(propName: string | number) {
-    if (typeof (propName) == 'number') {
+export function propertyKeyAsString(propName: string | number): string {
+    if (typeof (propName) === 'number') {
         return propName.toString();
     }
     return propName;
 }
 
-export function getPropName(propertyName: ts.PropertyName) {
+export function getPropName(propertyName: ts.PropertyName): string | number | ts.ComputedPropertyName {
     if (ts.isComputedPropertyName(propertyName)) {
         return propertyName;
     }
 
     let propName: number | string = jshelpers.getTextOfIdentifierOrLiteral(propertyName);
 
-    if (propertyName.kind == ts.SyntaxKind.NumericLiteral) {
+    if (propertyName.kind === ts.SyntaxKind.NumericLiteral) {
         propName = Number.parseFloat(propName);
         if (!isValidIndex(propName)) {
             propName = propName.toString();
         }
-    } else if (propertyName.kind == ts.SyntaxKind.StringLiteral) {
+    } else if (propertyName.kind === ts.SyntaxKind.StringLiteral) {
         let temp = Number(propName);
-        if (!isNaN(Number.parseFloat(propName)) && !isNaN(temp) && isValidIndex(temp) && String(temp) == propName) {
+        if (!isNaN(Number.parseFloat(propName)) && !isNaN(temp) && isValidIndex(temp) && String(temp) === propName) {
             propName = temp;
         }
     }
diff --git a/ts2panda/src/base/typeSystem.ts b/ts2panda/src/base/typeSystem.ts
index b25b270ddf..1b84aceb44 100644
--- a/ts2panda/src/base/typeSystem.ts
+++ b/ts2panda/src/base/typeSystem.ts
@@ -170,23 +170,23 @@ export abstract class BaseType {
         }
     }
 
-    protected addCurrentType(node: ts.Node, index: number) {
+    protected addCurrentType(node: ts.Node, index: number): void {
         this.typeRecorder.addType2Index(node, index);
     }
 
-    protected setVariable2Type(variableNode: ts.Node, index: number) {
+    protected setVariable2Type(variableNode: ts.Node, index: number): void {
         this.typeRecorder.setVariable2Type(variableNode, index);
     }
 
-    protected tryGetTypeIndex(typeNode: ts.Node) {
+    protected tryGetTypeIndex(typeNode: ts.Node): number {
         return this.typeRecorder.tryGetTypeIndex(typeNode);
     }
 
-    protected getOrCreateRecordForDeclNode(typeNode: ts.Node, variableNode?: ts.Node) {
+    protected getOrCreateRecordForDeclNode(typeNode: ts.Node, variableNode?: ts.Node): PrimitiveType {
         return this.typeChecker.getOrCreateRecordForDeclNode(typeNode, variableNode);
     }
 
-    protected getOrCreateRecordForTypeNode(typeNode: ts.TypeNode | undefined, variableNode?: ts.Node) {
+    protected getOrCreateRecordForTypeNode(typeNode: ts.TypeNode | undefined, variableNode?: ts.Node): PrimitiveType {
         return this.typeChecker.getOrCreateRecordForTypeNode(typeNode, variableNode);
     }
 
@@ -194,11 +194,11 @@ export abstract class BaseType {
         return PandaGen.appendTypeArrayBuffer(type);
     }
 
-    protected setTypeArrayBuffer(type: BaseType, index: number) {
+    protected setTypeArrayBuffer(type: BaseType, index: number): void {
         PandaGen.setTypeArrayBuffer(type, index);
     }
 
-    protected calculateIndex(builtinTypeIdx) {
+    protected calculateIndex(builtinTypeIdx): { typeIndex: number; shiftedTypeIndex: number; } {
         let typeIndex: number;
         let shiftedTypeIndex: number;
         let recordBuiltin = builtinTypeIdx && CmdOptions.needRecordBuiltinDtsType();
@@ -239,7 +239,7 @@ export class TypeSummary extends BaseType {
         }
     }
 
-    public setInfo(userDefinedClassNum: number, anonymousRedirect: Array<string>) {
+    public setInfo(userDefinedClassNum: number, anonymousRedirect: Array<string>): void {
         this.userDefinedClassNum = userDefinedClassNum;
         this.anonymousRedirect = anonymousRedirect;
         this.setTypeArrayBuffer(this, this.preservedIndex);
@@ -309,7 +309,7 @@ export class ClassType extends BaseType {
         }
     }
 
-    private fillInModifiers(node: ts.ClassDeclaration | ts.ClassExpression) {
+    private fillInModifiers(node: ts.ClassDeclaration | ts.ClassExpression): void {
         if (node.modifiers) {
             for (let modifier of node.modifiers) {
                 switch (modifier.kind) {
@@ -325,7 +325,7 @@ export class ClassType extends BaseType {
         }
     }
 
-    private fillInHeritages(node: ts.ClassDeclaration | ts.ClassExpression) {
+    private fillInHeritages(node: ts.ClassDeclaration | ts.ClassExpression): void {
         if (node.heritageClauses) {
             for (let heritage of node.heritageClauses) {
                 let heritageFullName = heritage.getText();
@@ -342,7 +342,7 @@ export class ClassType extends BaseType {
         }
     }
 
-    private fillInFields(member: ts.PropertyDeclaration) {
+    private fillInFields(member: ts.PropertyDeclaration): void {
         let fieldName = jshelpers.getTextOfIdentifierOrLiteral(member.name);
         let fieldInfo = Array<number>(PrimitiveType.ANY, AccessFlag.PUBLIC, ModifierReadonly.NONREADONLY);
         let isStatic: boolean = false;
@@ -372,8 +372,8 @@ export class ClassType extends BaseType {
             }
         }
 
-        let typeNode = member.type
-        let memberName = member.name
+        let typeNode = member.type;
+        let memberName = member.name;
         fieldInfo[0] = this.getOrCreateRecordForTypeNode(typeNode, memberName);
 
         if (isStatic) {
@@ -386,7 +386,7 @@ export class ClassType extends BaseType {
         }
     }
 
-    private fillInMethods(member: ClassMemberFunction) {
+    private fillInMethods(member: ClassMemberFunction): void {
         /**
          * a method like declaration in a new class must be a new type,
          * create this type and add it into typeRecorder if it's not from tsc's library
@@ -427,7 +427,7 @@ export class ClassType extends BaseType {
         }
     }
 
-    private fillInFieldsAndMethods(node: ts.ClassDeclaration | ts.ClassExpression) {
+    private fillInFieldsAndMethods(node: ts.ClassDeclaration | ts.ClassExpression): void {
         if (node.members) {
             for (let member of node.members) {
                 switch (member.kind) {
@@ -449,7 +449,7 @@ export class ClassType extends BaseType {
         }
     }
 
-    transfer2LiteralBuffer() {
+    transfer2LiteralBuffer(): LiteralBuffer {
         if (!this.typeIndex) {
             return;
         }
@@ -477,7 +477,7 @@ export class ClassType extends BaseType {
         return classTypeBuf;
     }
 
-    private transferFields2Literal(classTypeLiterals: Array<Literal>, isStatic: boolean) {
+    private transferFields2Literal(classTypeLiterals: Array<Literal>, isStatic: boolean): void {
         let transferredTarget: Map<string, Array<number>> = isStatic ? this.staticFields : this.fields;
 
         classTypeLiterals.push(new Literal(LiteralTag.INTEGER, transferredTarget.size));
@@ -489,7 +489,7 @@ export class ClassType extends BaseType {
         });
     }
 
-    private transferMethods2Literal(classTypeLiterals: Array<Literal>, isStatic: boolean) {
+    private transferMethods2Literal(classTypeLiterals: Array<Literal>, isStatic: boolean): void {
         let transferredTarget: Map<string, {typeIndex: number, isDeclare: boolean}> = isStatic ? this.staticMethods : this.methods;
 
         classTypeLiterals.push(new Literal(LiteralTag.INTEGER, transferredTarget.size));
@@ -544,7 +544,7 @@ export class FunctionType extends BaseType {
         let res = this.calculateIndex(builtinTypeIdx);
         this.typeIndex = res.typeIndex;
         this.shiftedTypeIndex = res.shiftedTypeIndex;
-        if (funcNode.kind == ts.SyntaxKind.GetAccessor || funcNode.kind == ts.SyntaxKind.SetAccessor) {
+        if (funcNode.kind === ts.SyntaxKind.GetAccessor || funcNode.kind === ts.SyntaxKind.SetAccessor) {
             this.getOrSetAccessorFlag = GetOrSetAccessorFlag.TRUE;
         }
 
@@ -563,11 +563,11 @@ export class FunctionType extends BaseType {
         this.setTypeArrayBuffer(this, this.typeIndex);
     }
 
-    public getFunctionName() {
+    public getFunctionName(): string {
         return this.name;
     }
 
-    private fillInModifiers(node: ts.FunctionLikeDeclaration | ts.MethodSignature) {
+    private fillInModifiers(node: ts.FunctionLikeDeclaration | ts.MethodSignature): void {
         if (node.modifiers) {
             for (let modifier of node.modifiers) {
                 switch (modifier.kind) {
@@ -605,31 +605,31 @@ export class FunctionType extends BaseType {
         }
     }
 
-    private fillInParameters(node: ts.FunctionLikeDeclaration | ts.MethodSignature) {
+    private fillInParameters(node: ts.FunctionLikeDeclaration | ts.MethodSignature): void {
         if (node.parameters) {
             for (let parameter of node.parameters) {
                 let typeNode = parameter.type;
                 let variableNode = parameter.name;
                 let typeIndex = this.getOrCreateRecordForTypeNode(typeNode, variableNode);
                 this.parameters.push(typeIndex);
-                if (variableNode.getFullText() == 'this') {
+                if (variableNode.getFullText() === 'this') {
                     this.containThisParam = true;
                 }
             }
         }
     }
 
-    private fillInReturn(node: ts.FunctionLikeDeclaration | ts.MethodSignature) {
+    private fillInReturn(node: ts.FunctionLikeDeclaration | ts.MethodSignature): void {
         let typeNode = node.type;
         let typeIndex = this.getOrCreateRecordForTypeNode(typeNode, typeNode);
         this.returnType = typeIndex;
     }
 
-    getModifier() {
+    getModifier(): number {
         return this.modifiers;
     }
 
-    hasModifier(modifier: MethodModifier) {
+    hasModifier(modifier: MethodModifier): boolean {
         return (this.modifiers & modifier) ? true : false;
     }
 
@@ -673,12 +673,12 @@ export class ExternalType extends BaseType {
     }
 
     transfer2LiteralBuffer(): LiteralBuffer {
-        let ImpTypeBuf = new LiteralBuffer();
-        let ImpTypeLiterals: Array<Literal> = new Array<Literal>();
-        ImpTypeLiterals.push(new Literal(LiteralTag.INTEGER, L2Type.EXTERNAL));
-        ImpTypeLiterals.push(new Literal(LiteralTag.STRING, this.fullRedirectNath));
-        ImpTypeBuf.addLiterals(...ImpTypeLiterals);
-        return ImpTypeBuf;
+        let impTypeBuf = new LiteralBuffer();
+        let impTypeLiterals: Array<Literal> = new Array<Literal>();
+        impTypeLiterals.push(new Literal(LiteralTag.INTEGER, L2Type.EXTERNAL));
+        impTypeLiterals.push(new Literal(LiteralTag.STRING, this.fullRedirectNath));
+        impTypeBuf.addLiterals(...impTypeLiterals);
+        return impTypeBuf;
     }
 }
 
@@ -692,7 +692,7 @@ export class UnionType extends BaseType {
         this.setOrReadFromArrayRecord(typeNode);
     }
 
-    setOrReadFromArrayRecord(typeNode: ts.Node) {
+    setOrReadFromArrayRecord(typeNode: ts.Node): void {
         let unionStr = typeNode.getText();
         if (this.hasUnionTypeMapping(unionStr)) {
             this.shiftedTypeIndex = this.getFromUnionTypeMap(unionStr)!;
@@ -705,19 +705,19 @@ export class UnionType extends BaseType {
         this.setTypeArrayBuffer(this, this.typeIndex);
     }
 
-    hasUnionTypeMapping(unionStr: string) {
+    hasUnionTypeMapping(unionStr: string): boolean {
         return this.typeRecorder.hasUnionTypeMapping(unionStr);
     }
 
-    getFromUnionTypeMap(unionStr: string) {
+    getFromUnionTypeMap(unionStr: string): number {
         return this.typeRecorder.getFromUnionTypeMap(unionStr);
     }
 
-    setUnionTypeMap(unionStr: string, shiftedTypeIndex: number) {
+    setUnionTypeMap(unionStr: string, shiftedTypeIndex: number): void {
         return this.typeRecorder.setUnionTypeMap(unionStr, shiftedTypeIndex);
     }
 
-    fillInUnionArray(typeNode: ts.Node, unionedTypeArray: Array<number>) {
+    fillInUnionArray(typeNode: ts.Node, unionedTypeArray: Array<number>): void {
         for (let element of (<ts.UnionType><any>typeNode).types) {
             let elementNode = <ts.TypeNode><any>element;
             let typeIndex = this.getOrCreateRecordForTypeNode(elementNode, elementNode);
@@ -726,15 +726,15 @@ export class UnionType extends BaseType {
     }
 
     transfer2LiteralBuffer(): LiteralBuffer {
-        let UnionTypeBuf = new LiteralBuffer();
-        let UnionTypeLiterals: Array<Literal> = new Array<Literal>();
-        UnionTypeLiterals.push(new Literal(LiteralTag.INTEGER, L2Type.UNION));
-        UnionTypeLiterals.push(new Literal(LiteralTag.INTEGER, this.unionedTypeArray.length));
+        let unionTypeBuf = new LiteralBuffer();
+        let unionTypeLiterals: Array<Literal> = new Array<Literal>();
+        unionTypeLiterals.push(new Literal(LiteralTag.INTEGER, L2Type.UNION));
+        unionTypeLiterals.push(new Literal(LiteralTag.INTEGER, this.unionedTypeArray.length));
         for (let type of this.unionedTypeArray) {
-            this.transferType2Literal(type, UnionTypeLiterals);
+            this.transferType2Literal(type, unionTypeLiterals);
         }
-        UnionTypeBuf.addLiterals(...UnionTypeLiterals);
-        return UnionTypeBuf;
+        unionTypeBuf.addLiterals(...unionTypeLiterals);
+        return unionTypeBuf;
     }
 }
 
@@ -749,7 +749,7 @@ export class ArrayType extends BaseType {
         this.setOrReadFromArrayRecord();
     }
 
-    setOrReadFromArrayRecord() {
+    setOrReadFromArrayRecord(): void {
         if (this.hasArrayTypeMapping(this.referedTypeIndex)) {
             this.shiftedTypeIndex = this.getFromArrayTypeMap(this.referedTypeIndex)!;
         } else {
@@ -760,15 +760,15 @@ export class ArrayType extends BaseType {
         }
     }
 
-    hasArrayTypeMapping(referedTypeIndex: number) {
+    hasArrayTypeMapping(referedTypeIndex: number): boolean {
         return this.typeRecorder.hasArrayTypeMapping(referedTypeIndex);
     }
 
-    getFromArrayTypeMap(referedTypeIndex: number) {
+    getFromArrayTypeMap(referedTypeIndex: number): number {
         return this.typeRecorder.getFromArrayTypeMap(referedTypeIndex);
     }
 
-    setArrayTypeMap(referedTypeIndex: number, shiftedTypeIndex: number) {
+    setArrayTypeMap(referedTypeIndex: number, shiftedTypeIndex: number): void {
         return this.typeRecorder.setArrayTypeMap(referedTypeIndex, shiftedTypeIndex);
     }
 
@@ -795,7 +795,7 @@ export class ObjectType extends BaseType {
         this.setTypeArrayBuffer(this, this.typeIndex);
     }
 
-    fillInMembers(objNode: ts.TypeLiteralNode) {
+    fillInMembers(objNode: ts.TypeLiteralNode): void {
         for (let member of objNode.members) {
             let propertySig = <ts.PropertySignature>member;
             let name = member.name ? member.name.getText() : "#undefined";
@@ -838,7 +838,7 @@ export class InterfaceType extends BaseType {
         this.setTypeArrayBuffer(this, this.typeIndex);
     }
 
-    private fillInHeritages(node: ts.InterfaceDeclaration) {
+    private fillInHeritages(node: ts.InterfaceDeclaration): void {
         if (node.heritageClauses) {
             for (let heritage of node.heritageClauses) {
                 for (let heritageType of heritage.types) {
@@ -850,7 +850,7 @@ export class InterfaceType extends BaseType {
         }
     }
 
-    private fillInFields(member: ts.PropertySignature) {
+    private fillInFields(member: ts.PropertySignature): void {
         let fieldName = jshelpers.getTextOfIdentifierOrLiteral(member.name);
         let fieldInfo = Array<number>(PrimitiveType.ANY, AccessFlag.PUBLIC, ModifierReadonly.NONREADONLY);
         if (member.modifiers) {
@@ -879,7 +879,7 @@ export class InterfaceType extends BaseType {
         this.fields.set(fieldName, fieldInfo);
     }
 
-    private fillInMethods(member: ts.MethodSignature) {
+    private fillInMethods(member: ts.MethodSignature): void {
         /**
          * a method like declaration in a new class must be a new type,
          * create this type and add it into typeRecorder if it's not from tsc's library
@@ -897,7 +897,7 @@ export class InterfaceType extends BaseType {
         this.methods.push(typeIndex!);
     }
 
-    private fillInFieldsAndMethods(node: ts.InterfaceDeclaration) {
+    private fillInFieldsAndMethods(node: ts.InterfaceDeclaration): void {
         if (node.members) {
             for (let member of node.members) {
                 switch (member.kind) {
@@ -916,7 +916,7 @@ export class InterfaceType extends BaseType {
         }
     }
 
-    transfer2LiteralBuffer() {
+    transfer2LiteralBuffer(): LiteralBuffer {
         let interfaceTypeBuf = new LiteralBuffer();
         let interfaceTypeLiterals: Array<Literal> = new Array<Literal>();
         // the first element is to determine the L2 type
@@ -935,7 +935,7 @@ export class InterfaceType extends BaseType {
         return interfaceTypeBuf;
     }
 
-    private transferFields2Literal(interfaceTypeLiterals: Array<Literal>) {
+    private transferFields2Literal(interfaceTypeLiterals: Array<Literal>): void {
         let transferredTarget: Map<string, Array<number>> = this.fields;
 
         interfaceTypeLiterals.push(new Literal(LiteralTag.INTEGER, transferredTarget.size));
@@ -947,7 +947,7 @@ export class InterfaceType extends BaseType {
         });
     }
 
-    private transferMethods2Literal(interfaceTypeLiterals: Array<Literal>) {
+    private transferMethods2Literal(interfaceTypeLiterals: Array<Literal>): void {
         let transferredTarget: Array<number> = this.methods;
 
         interfaceTypeLiterals.push(new Literal(LiteralTag.INTEGER, transferredTarget.length));
@@ -972,7 +972,7 @@ export class BuiltinContainerType extends BaseType {
         this.setBuiltinContainer2InstanceMap(builtinContainerSignature, this.shiftedTypeIndex);
     }
 
-    setBuiltinContainer2InstanceMap(builtinContainerSignature: object, index: number) {
+    setBuiltinContainer2InstanceMap(builtinContainerSignature: object, index: number): void {
         return this.typeRecorder.setBuiltinContainer2InstanceMap(builtinContainerSignature, index);
     }
 
diff --git a/ts2panda/src/base/util.ts b/ts2panda/src/base/util.ts
index 24bd25e9a9..57e52b7ac2 100644
--- a/ts2panda/src/base/util.ts
+++ b/ts2panda/src/base/util.ts
@@ -55,7 +55,7 @@ export function hasExportKeywordModifier(node: ts.Node): boolean {
     let hasExport: boolean = false;
     if (node.modifiers) {
         node.modifiers.forEach((mod) => {
-            if (mod.kind == ts.SyntaxKind.ExportKeyword) {
+            if (mod.kind === ts.SyntaxKind.ExportKeyword) {
                 hasExport = true;
             }
         });
@@ -68,7 +68,7 @@ export function hasDefaultKeywordModifier(node: ts.Node): boolean {
     let hasDefault: boolean = false;
     if (node.modifiers) {
         node.modifiers.forEach((mod) => {
-            if (mod.kind == ts.SyntaxKind.DefaultKeyword) {
+            if (mod.kind === ts.SyntaxKind.DefaultKeyword) {
                 hasDefault = true;
             }
         });
@@ -77,8 +77,8 @@ export function hasDefaultKeywordModifier(node: ts.Node): boolean {
     return hasDefault;
 }
 
-export function execute(cmd: string, args: Array<string>) {
-    var spawn = require('child_process').spawn;
+export function execute(cmd: string, args: Array<string>): number {
+    let spawn = require('child_process').spawn;
 
     let child = spawn(cmd, [...args], {
         stdio: ['pipe', 'inherit', 'inherit']
@@ -96,14 +96,14 @@ export function execute(cmd: string, args: Array<string>) {
     return 1;
 }
 
-export function addUnicodeEscape(text: string) {
+export function addUnicodeEscape(text: string): string {
     let firstIdx = 0;
     let secondIdx = 0;
     let len = text.length;
     let newText = "";
     while (secondIdx != len) {
-        if (text[secondIdx] == '\\' && secondIdx + 1 != len && text[secondIdx + 1] == 'u') {
-            if (secondIdx != 0 && text[secondIdx - 1] == '\\') {
+        if (text[secondIdx] === '\\' && secondIdx + 1 != len && text[secondIdx + 1] === 'u') {
+            if (secondIdx != 0 && text[secondIdx - 1] === '\\') {
                 newText += text.substr(firstIdx, secondIdx - firstIdx) + "\\\\" + "\\u";
             } else {
                 newText += text.substr(firstIdx, secondIdx - firstIdx) + "\\" + "\\u";
@@ -115,39 +115,39 @@ export function addUnicodeEscape(text: string) {
         }
     }
 
-    if (secondIdx == len && firstIdx != secondIdx) {
+    if (secondIdx === len && firstIdx != secondIdx) {
         newText += text.substr(firstIdx);
     }
 
     return newText;
 }
 
-export function isBindingPattern(node: ts.Node) {
+export function isBindingPattern(node: ts.Node): boolean {
     return ts.isArrayBindingPattern(node) || ts.isObjectBindingPattern(node);
 }
 
-export function isObjectBindingOrAssignmentPattern(node: ts.Node) {
+export function isObjectBindingOrAssignmentPattern(node: ts.Node): boolean {
     return ts.isObjectLiteralExpression(node) || ts.isObjectBindingPattern(node);
 }
 
-export function isArrayBindingOrAssignmentPattern(node: ts.Node) {
+export function isArrayBindingOrAssignmentPattern(node: ts.Node): boolean {
     return ts.isArrayLiteralExpression(node) || ts.isArrayBindingPattern(node);
 }
 
-export function isBindingOrAssignmentPattern(node: ts.Node) {
+export function isBindingOrAssignmentPattern(node: ts.Node): boolean {
     return isArrayBindingOrAssignmentPattern(node) || isObjectBindingOrAssignmentPattern(node);
 }
 
-export function isMemberExpression(node: ts.Node) {
-    if (ts.isPropertyAccessExpression(node)
-        || ts.isElementAccessExpression(node)) {
+export function isMemberExpression(node: ts.Node): boolean {
+    if (ts.isPropertyAccessExpression(node) ||
+        ts.isElementAccessExpression(node)) {
         return true;
     }
 
     return false;
 }
 
-export function isUndefinedIdentifier(node: ts.Node) {
+export function isUndefinedIdentifier(node: ts.Node): boolean {
     if (!ts.isIdentifier(node)) {
         return false;
     }
@@ -159,7 +159,7 @@ export function isUndefinedIdentifier(node: ts.Node) {
     return true;
 }
 
-export function isAnonymousFunctionDefinition(node: ts.Node) {
+export function isAnonymousFunctionDefinition(node: ts.Node): boolean {
     if (!isFunctionLikeDeclaration(node)) {
         return false;
     }
@@ -171,29 +171,29 @@ export function isAnonymousFunctionDefinition(node: ts.Node) {
     }
 }
 
-export function escapeUnicode(data: string) {
+export function escapeUnicode(data: string): string {
     let char = '\n';
     let i = 0;
     let j = 0;
-    let new_data = ""
+    let newData = "";
     while ((j = data.indexOf(char, i)) !== -1) {
         let tmp = data.substring(i, j);
         if (tmp.indexOf("\\u") != -1) {
             tmp = addUnicodeEscape(tmp);
         }
-        new_data = new_data.concat(tmp, "\n");
+        newData = newData.concat(tmp, "\n");
         i = j + 1;
     }
 
-    new_data = new_data.concat("}\n");
-    return new_data
+    newData = newData.concat("}\n");
+    return newData;
 }
 
-export function initiateTs2abc(args: Array<string>) {
+export function initiateTs2abc(args: Array<string>): any {
     let js2abc = path.join(path.resolve(__dirname, '../bin'), "js2abc");
     args.unshift("--compile-by-pipe");
     // @ts-ignore
-    var spawn = require('child_process').spawn;
+    let spawn = require('child_process').spawn;
     let child = spawn(js2abc, [...args], {
         stdio: ['pipe', 'inherit', 'inherit', 'pipe']
     });
@@ -201,7 +201,7 @@ export function initiateTs2abc(args: Array<string>) {
     return child;
 }
 
-export function terminateWritePipe(ts2abc: any) {
+export function terminateWritePipe(ts2abc: any): void {
     if (!ts2abc) {
         LOGD("ts2abc is not a valid object");
     }
@@ -209,7 +209,7 @@ export function terminateWritePipe(ts2abc: any) {
     ts2abc.stdio[3].end();
 }
 
-export function listenChildExit(child: any) {
+export function listenChildExit(child: any): void {
     if (!child) {
         LOGD("child is not a valid object");
     }
@@ -222,7 +222,7 @@ export function listenChildExit(child: any) {
     });
 }
 
-export function listenErrorEvent(child: any) {
+export function listenErrorEvent(child: any): void {
     if (!child) {
         LOGD("child is not a valid object");
     }
@@ -232,7 +232,7 @@ export function listenErrorEvent(child: any) {
     });
 }
 
-export function isRangeInst(ins: IRNode) {
+export function isRangeInst(ins: IRNode): boolean {
     if (ins instanceof Callthisrange ||
         ins instanceof WideCallthisrange ||
         ins instanceof Callrange ||
@@ -281,11 +281,11 @@ export function getRangeExplicitVregNums(ins: IRNode): number {
     return ins instanceof Createobjectwithexcludedkeys ? 2 : 1;
 }
 
-export function isRestParameter(parameter: ts.ParameterDeclaration) {
+export function isRestParameter(parameter: ts.ParameterDeclaration): boolean {
     return parameter.dotDotDotToken ? true : false;
 }
 
-export function getParamLengthOfFunc(node: ts.FunctionLikeDeclaration) {
+export function getParamLengthOfFunc(node: ts.FunctionLikeDeclaration): number {
     let length = 0;
     let validLengthRange = true;
     let parameters = node.parameters;
@@ -304,7 +304,7 @@ export function getParamLengthOfFunc(node: ts.FunctionLikeDeclaration) {
     return length;
 }
 
-export function getParameterLength4Ctor(node: ts.ClassLikeDeclaration) {
+export function getParameterLength4Ctor(node: ts.ClassLikeDeclaration): number {
     if (!extractCtorOfClass(node)) {
         return 0;
     }
@@ -321,7 +321,7 @@ export function getParameterLength4Ctor(node: ts.ClassLikeDeclaration) {
     return getParamLengthOfFunc(ctorNode!);
 }
 
-export function setPos(node: ts.Node) {
+export function setPos(node: ts.Node): ts.Node {
     ts.setTextRange(node, {pos:-1, end:-1});
     node.forEachChild(childNode => {
         setPos(childNode);
@@ -329,18 +329,18 @@ export function setPos(node: ts.Node) {
     return node;
 }
 
-export function getRecordTypeFlag(recordType: boolean) {
+export function getRecordTypeFlag(recordType: boolean): boolean {
     return recordType && CmdOptions.needRecordType() && CompilerDriver.isTsFile;
 }
 
 export function isBase64Str(input: string): boolean {
-    if (input == '' || input.trim() == '') {
+    if (input === '' || input.trim() === '') {
         return false;
     }
-    return Buffer.from(Buffer.from(input, 'base64').toString()).toString('base64') == input;
+    return Buffer.from(Buffer.from(input, 'base64').toString()).toString('base64') === input;
 }
 
-export function transformCommonjsModule(sourceFile: ts.SourceFile) {
+export function transformCommonjsModule(sourceFile: ts.SourceFile): ts.SourceFile {
     /*
      * Transform the commonjs module's AST by wrap the sourceCode & use Reflect.apply to invoke this wrapper with [this]
      * pointing to [exports] object
@@ -402,12 +402,12 @@ export function hasAbstractModifier(node: ts.Node): boolean {
 export const MAX_INT8 = 127;
 export const MAX_INT16 = 32767;
 
-export function getOutputBinName(node: ts.SourceFile) {
+export function getOutputBinName(node: ts.SourceFile): string {
     let outputBinName = CmdOptions.getOutputBinName();
     let fileName = node.fileName.substring(0, node.fileName.lastIndexOf('.'));
     let inputFileName = CmdOptions.getInputFileName();
     if (/^win/.test(require('os').platform())) {
-        var inputFileTmps = inputFileName.split(path.sep);
+        let inputFileTmps = inputFileName.split(path.sep);
         inputFileName = path.posix.join(...inputFileTmps);
     }
 
@@ -420,7 +420,7 @@ export function getOutputBinName(node: ts.SourceFile) {
 export function getRecordName(node: ts.SourceFile): string {
     let recordName = CmdOptions.getRecordName();
 
-    if (recordName == "" && CmdOptions.isMergeAbc()) {
+    if (recordName === "" && CmdOptions.isMergeAbc()) {
         let outputBinName = getOutputBinName(node);
         recordName = path.basename(outputBinName, path.extname(outputBinName));
     }
@@ -437,7 +437,7 @@ export function getLiteralKey(node: ts.SourceFile, idx:number): string {
  */
 function getNodeForGeneratedName(
     // @ts-ignore
-    name: ts.GeneratedIdentifier) {
+    name: ts.GeneratedIdentifier): ts.Node {
     const autoGenerateId = name.autoGenerateId;
     let node = name as ts.Node;
     // @ts-ignore
@@ -446,11 +446,11 @@ function getNodeForGeneratedName(
         node = original;
 
         // if "node" is a different generated name (having a different "autoGenerateId"), use it and stop traversing.
-        if (ts.isIdentifier(node)
+        if (ts.isIdentifier(node) &&
             // @ts-ignore
-            && !!(node.autoGenerateFlags! & ts.GeneratedIdentifierFlags.Node)
+            !!(node.autoGenerateFlags! & ts.GeneratedIdentifierFlags.Node) &&
             // @ts-ignore
-            && node.autoGenerateId !== autoGenerateId) {
+            node.autoGenerateId !== autoGenerateId) {
             break;
         }
         // @ts-ignore
@@ -492,7 +492,7 @@ function generateNameForTempAndLoopVariable(node: ts.Node): string {
     }
     let generatedName = generateUniqueName();
     // @ts-ignore
-    if ((node.autoGenerateFlags & ts.GeneratedIdentifierFlags.KindMask) == ts.GeneratedIdentifierFlags.Unique) {
+    if ((node.autoGenerateFlags & ts.GeneratedIdentifierFlags.KindMask) === ts.GeneratedIdentifierFlags.Unique) {
         // Unique names are generated and cached based on their unique autoGenerateId and original idText.
         // @ts-ignore
         generatedName = (<ts.Identifier>node).escapedText + generatedName;
@@ -501,11 +501,11 @@ function generateNameForTempAndLoopVariable(node: ts.Node): string {
     return generatedName;
 }
 
-export function resetUniqueNameIndex() {
+export function resetUniqueNameIndex(): void {
     uniqueNameIndex = 0;
 }
 
-export function makeNameForGeneratedNode(node: ts.Node) {
+export function makeNameForGeneratedNode(node: ts.Node): void {
     node.forEachChild(childNode => {
         switch (childNode.kind) {
             case ts.SyntaxKind.Identifier: {
diff --git a/ts2panda/src/base/vregisterCache.ts b/ts2panda/src/base/vregisterCache.ts
index 4bbb061f74..8129c8dc4e 100644
--- a/ts2panda/src/base/vregisterCache.ts
+++ b/ts2panda/src/base/vregisterCache.ts
@@ -34,30 +34,30 @@ import { expandLexEnv } from "./lexEnv";
 
 export enum CacheList {
     MIN,
-    NaN = MIN,
+    NAN = MIN,
     HOLE,
     FUNC, // load function
-    Infinity,
-    undefined,
-    Symbol,
-    Null,
-    Global,
-    LexEnv,
-    True,
-    False,
+    INFINITY,
+    UNDEFINED,
+    SYMBOL,
+    NULL,
+    GLOBAL,
+    LEXENV,
+    TRUE,
+    FALSE,
     MAX
 }
 let cacheExpandHandlers = new Map([
     [CacheList.HOLE, expandHole],
-    [CacheList.NaN, expandNaN],
-    [CacheList.Infinity, expandInfinity],
-    [CacheList.undefined, expandUndefined],
-    [CacheList.Symbol, expandSymbol],
-    [CacheList.Null, expandNull],
-    [CacheList.Global, expandGlobal],
-    [CacheList.LexEnv, expandLexEnv],
-    [CacheList.True, expandTrue],
-    [CacheList.False, expandFalse],
+    [CacheList.NAN, expandNaN],
+    [CacheList.INFINITY, expandInfinity],
+    [CacheList.UNDEFINED, expandUndefined],
+    [CacheList.SYMBOL, expandSymbol],
+    [CacheList.NULL, expandNull],
+    [CacheList.GLOBAL, expandGlobal],
+    [CacheList.LEXENV, expandLexEnv],
+    [CacheList.TRUE, expandTrue],
+    [CacheList.FALSE, expandFalse],
     [CacheList.FUNC, expandFunc],
 ]);
 
@@ -70,7 +70,7 @@ class CacheItem {
     private flag: boolean;
     private vreg: VReg | undefined;
     private expander: Function;
-    isNeeded() {
+    isNeeded(): boolean {
         return this.flag;
     }
     getCache(): VReg {
@@ -80,7 +80,7 @@ class CacheItem {
         }
         return this.vreg;
     }
-    getExpander() {
+    getExpander(): Function {
         return this.expander;
     }
 }
@@ -96,7 +96,7 @@ export class VregisterCache {
             this.cache[i] = new CacheItem(handler);
         }
     }
-    getCache(index: CacheList) {
+    getCache(index: CacheList): CacheItem {
         if (index < CacheList.MIN || index > CacheList.MAX) {
             throw new Error("invalid builtin index");
         }
@@ -104,7 +104,7 @@ export class VregisterCache {
     }
 }
 
-export function getVregisterCache(pandaGen: PandaGen, index: CacheList) {
+export function getVregisterCache(pandaGen: PandaGen, index: CacheList): VReg {
     let cache = pandaGen.getVregisterCache();
     let cacheItem = cache.getCache(index);
 
diff --git a/ts2panda/src/cmdOptions.ts b/ts2panda/src/cmdOptions.ts
index ff02ad83b2..173cfc5aca 100644
--- a/ts2panda/src/cmdOptions.ts
+++ b/ts2panda/src/cmdOptions.ts
@@ -93,7 +93,7 @@ export class CmdOptions {
         return this.options["debug"];
     }
 
-    static setWatchEvaluateExpressionArgs(watchArgs: string[]) {
+    static setWatchEvaluateExpressionArgs(watchArgs: string[]): void {
         this.options["debug-add-watch"] = watchArgs;
     }
 
@@ -105,11 +105,11 @@ export class CmdOptions {
     }
 
     static isWatchEvaluateDeamonMode(): boolean {
-        return CmdOptions.getDeamonModeArgs()[0] == "start";
+        return CmdOptions.getDeamonModeArgs()[0] === "start";
     }
 
     static isStopEvaluateDeamonMode(): boolean {
-        return CmdOptions.getDeamonModeArgs()[0] == "stop";
+        return CmdOptions.getDeamonModeArgs()[0] === "stop";
     }
 
     static getEvaluateDeamonPath(): string {
@@ -132,7 +132,7 @@ export class CmdOptions {
     }
 
     static getWatchTimeOutValue(): number {
-        if (this.options["debug-add-watch"].length == 2) {
+        if (this.options["debug-add-watch"].length === 2) {
             return 0;
         }
         return this.options["debug-add-watch"][2];
@@ -220,7 +220,7 @@ export class CmdOptions {
 
     static getOutputBinName(): string {
         let outputFile = this.options.output;
-        if (outputFile == "") {
+        if (outputFile === "") {
             outputFile = CmdOptions.getInputFileName() + ".abc";
         }
         return outputFile;
@@ -281,8 +281,8 @@ export class CmdOptions {
 
     static getVersion(isBcVersion: boolean = true): void {
         let js2abc = path.join(path.resolve(__dirname, '../bin'), "js2abc");
-        let version_arg = isBcVersion ? "--bc-version" : "--bc-min-version"
-        execute(`${js2abc}`, [version_arg]);
+        let versionArg = isBcVersion ? "--bc-version" : "--bc-min-version";
+        execute(`${js2abc}`, [versionArg]);
     }
 
     static isBcMinVersion(): boolean {
diff --git a/ts2panda/src/compiler.ts b/ts2panda/src/compiler.ts
index 4818a0fd77..968b23ccd2 100644
--- a/ts2panda/src/compiler.ts
+++ b/ts2panda/src/compiler.ts
@@ -124,7 +124,7 @@ import {
 } from "./variable";
 import {
     compileCommaListExpression
-} from "./expression/compileCommaListExpression"
+} from "./expression/compileCommaListExpression";
 
 export enum ControlFlowChange { Continue, Break }
 export class Compiler {
@@ -154,35 +154,35 @@ export class Compiler {
         }
 
         // spare v3 to save the currrent lexcial env
-        getVregisterCache(this.pandaGen, CacheList.LexEnv);
+        getVregisterCache(this.pandaGen, CacheList.LEXENV);
 
         this.pandaGen.loadAccFromArgs(this.rootNode);
     }
 
-    compile() {
+    compile(): void {
         this.storeFuncObj2LexEnvIfNeeded();
         this.compileLexicalBindingForArrowFunction();
 
-        if (this.rootNode.kind == ts.SyntaxKind.SourceFile) {
+        if (this.rootNode.kind === ts.SyntaxKind.SourceFile) {
             this.compileSourceFileOrBlock(<ts.SourceFile>this.rootNode);
         } else {
             this.compileFunctionLikeDeclaration(<ts.FunctionLikeDeclaration>this.rootNode);
         }
     }
 
-    pushEnv(env: VReg) {
+    pushEnv(env: VReg): void {
         this.envUnion.push(env);
     }
 
-    popEnv() {
+    popEnv(): void {
         this.envUnion.pop();
     }
 
-    getCurrentEnv() {
+    getCurrentEnv(): VReg {
         return this.envUnion[this.envUnion.length - 1];
     }
 
-    private storeFuncObj2LexEnvIfNeeded() {
+    private storeFuncObj2LexEnvIfNeeded(): void {
         let rootNode = this.rootNode;
         if (!ts.isFunctionExpression(rootNode) && !ts.isMethodDeclaration(rootNode)) {
             return;
@@ -191,15 +191,15 @@ export class Compiler {
         if ((<ts.FunctionLikeDeclaration>rootNode).name) {
             let funcName = jshelpers.getTextOfIdentifierOrLiteral((<ts.FunctionLikeDeclaration>rootNode).name);
             let v = functionScope.find(funcName);
-            if (v.scope == functionScope) {
-                this.pandaGen.loadAccumulator(NodeKind.FirstNodeOfFunction,
+            if (v.scope === functionScope) {
+                this.pandaGen.loadAccumulator(NodeKind.FIRST_NODE_OF_FUNCTION,
                                               getVregisterCache(this.pandaGen, CacheList.FUNC));
-                this.pandaGen.storeAccToLexEnv(NodeKind.FirstNodeOfFunction, v.scope, v.level, v.v, true);
+                this.pandaGen.storeAccToLexEnv(NodeKind.FIRST_NODE_OF_FUNCTION, v.scope, v.level, v.v, true);
             }
         }
     }
 
-    private compileLexicalBindingForArrowFunction() {
+    private compileLexicalBindingForArrowFunction(): void {
         let rootNode = this.rootNode;
         if (ts.isArrowFunction(rootNode)) {
             return;
@@ -215,7 +215,7 @@ export class Compiler {
         }
     }
 
-    private storeMandatoryArgToLexEnv(arg: string) {
+    private storeMandatoryArgToLexEnv(arg: string): void {
         let v = this.scope.findLocal(arg);
         if (!v) {
             throw new Error("Mandatory Arguments should be found locally");
@@ -224,22 +224,22 @@ export class Compiler {
             return;
         }
 
-        let vreg = arg == MandatoryFuncObj ? getVregisterCache(this.pandaGen, CacheList.FUNC) :
+        let vreg = arg === MandatoryFuncObj ? getVregisterCache(this.pandaGen, CacheList.FUNC) :
                                        this.pandaGen.getVregForVariable(v);
         this.pandaGen.storeLexicalVar(this.rootNode, 0, v.lexIndex(), vreg);
     }
 
-    private compileSourceFileOrBlock(body: ts.SourceFile | ts.Block) {
+    private compileSourceFileOrBlock(body: ts.SourceFile | ts.Block): void {
         let statements = body.statements;
         let unreachableFlag = false;
 
         if (body.parent && ts.isConstructorDeclaration(body.parent)) {
-            compileDefaultInitClassMembers(this, body.parent)
+            compileDefaultInitClassMembers(this, body.parent);
         }
 
         statements.forEach((stmt) => {
             this.compileStatement(stmt);
-            if (stmt.kind == ts.SyntaxKind.ReturnStatement) {
+            if (stmt.kind === ts.SyntaxKind.ReturnStatement) {
                 unreachableFlag = true;
             }
         });
@@ -252,17 +252,17 @@ export class Compiler {
             return ;
         }
         // exit GlobalScopefunction or Function Block return
-        this.funcBuilder.implicitReturn(NodeKind.Invalid);
+        this.funcBuilder.implicitReturn(NodeKind.INVALID);
     }
 
     private compileFunctionBody(kind: number, body: ts.ConciseBody): void {
         let pandaGen = this.pandaGen;
 
-        if (body.kind == ts.SyntaxKind.Block) {
+        if (body.kind === ts.SyntaxKind.Block) {
             this.pushScope(body);
             this.compileSourceFileOrBlock(<ts.Block>body);
             this.popScope();
-        } else if (kind == ts.SyntaxKind.ArrowFunction) {
+        } else if (kind === ts.SyntaxKind.ArrowFunction) {
             this.compileExpression(<ts.Expression>body);
 
             let retValue = pandaGen.getTemp();
@@ -270,12 +270,12 @@ export class Compiler {
 
             if (this.funcBuilder instanceof AsyncFunctionBuilder || this.funcBuilder instanceof AsyncGeneratorFunctionBuilder) {
                 this.funcBuilder.resolve(body, retValue);
-                pandaGen.return(NodeKind.Invalid);
+                pandaGen.return(NodeKind.INVALID);
             } else {
                 pandaGen.loadAccumulator(body, retValue);
             }
             pandaGen.freeTemps(retValue);
-            pandaGen.return(NodeKind.Invalid);
+            pandaGen.return(NodeKind.INVALID);
         } else {
             throw new Error("Node " + this.getNodeName(body) + " is unimplemented as a function body");
         }
@@ -314,7 +314,7 @@ export class Compiler {
                 pandaGen.condition(
                     decl,
                     ts.SyntaxKind.EqualsEqualsEqualsToken,
-                    getVregisterCache(pandaGen, CacheList.undefined),
+                    getVregisterCache(pandaGen, CacheList.UNDEFINED),
                     endLabel);
                 this.compileExpression(param.initializer);
                 pandaGen.storeAccumulator(param, paramReg);
@@ -334,7 +334,7 @@ export class Compiler {
 
         if (decl.modifiers) {
             for (let i = 0; i < decl.modifiers.length; i++) {
-                if (decl.modifiers[i].kind == ts.SyntaxKind.AsyncKeyword) {
+                if (decl.modifiers[i].kind === ts.SyntaxKind.AsyncKeyword) {
                     // async generator
                     if (decl.asteriskToken) {
                         return new AsyncGeneratorFunctionBuilder(pandaGen, this);
@@ -364,7 +364,7 @@ export class Compiler {
             }
         }
 
-        if (decl.kind == ts.SyntaxKind.FunctionExpression) {
+        if (decl.kind === ts.SyntaxKind.FunctionExpression) {
             if (decl.name) {
                 let funcName = jshelpers.getTextOfIdentifierOrLiteral(decl.name);
                 (<VariableScope>pandaGen.getScope()!).addFuncName(funcName);
@@ -381,7 +381,7 @@ export class Compiler {
     }
 
 
-    compileStatement(stmt: ts.Statement) {
+    compileStatement(stmt: ts.Statement): void {
         // for debug info
         this.pandaGen.setFirstStmt(stmt);
 
@@ -464,7 +464,7 @@ export class Compiler {
         }
     }
 
-    private compileBlock(block: ts.Block) {
+    private compileBlock(block: ts.Block): void {
         this.pushScope(block);
         hoistFunctionInBlock(this.scope, this.pandaGen, isStrictMode(block), this);
 
@@ -473,32 +473,32 @@ export class Compiler {
         this.popScope();
     }
 
-    private compileVariableStatement(stmt: ts.VariableStatement) {
+    private compileVariableStatement(stmt: ts.VariableStatement): void {
         let declList = stmt.declarationList;
         declList.declarations.forEach((decl) => {
             this.compileVariableDeclaration(decl)
         });
     }
 
-    compileVariableDeclaration(decl: ts.VariableDeclaration) {
+    compileVariableDeclaration(decl: ts.VariableDeclaration): void {
         let lref = LReference.generateLReference(this, decl.name, true);
         if (decl.initializer) {
             this.compileExpression(decl.initializer);
         } else {
             // global var without init should not be assigned undefined twice
-            if (astutils.getVarDeclarationKind(decl) == VarDeclarationKind.VAR) {
+            if (astutils.getVarDeclarationKind(decl) === VarDeclarationKind.VAR) {
                 return;
             }
 
-            if ((astutils.getVarDeclarationKind(decl) == VarDeclarationKind.LET)
-                && decl.parent.kind != ts.SyntaxKind.CatchClause) {
-                this.pandaGen.loadAccumulator(decl, getVregisterCache(this.pandaGen, CacheList.undefined));
+            if ((astutils.getVarDeclarationKind(decl) === VarDeclarationKind.LET) &&
+                decl.parent.kind != ts.SyntaxKind.CatchClause) {
+                this.pandaGen.loadAccumulator(decl, getVregisterCache(this.pandaGen, CacheList.UNDEFINED));
             }
         }
         lref.setValue();
     }
 
-    private compileIfStatement(stmt: ts.IfStatement) {
+    private compileIfStatement(stmt: ts.IfStatement): void {
         this.pushScope(stmt);
         let ifElseLabel = new Label();
         let ifEndLabel = new Label();
@@ -514,13 +514,13 @@ export class Compiler {
         this.popScope();
     }
 
-    private popLoopEnv(node: ts.Node, times: number) {
+    private popLoopEnv(node: ts.Node, times: number): void {
         while(times--) {
             this.pandaGen.popLexicalEnv(node);
         }
     }
 
-    private popLoopEnvWhenContinueOrBreak(labelTarget: LabelTarget, isContinue: boolean) {
+    private popLoopEnvWhenContinueOrBreak(labelTarget: LabelTarget, isContinue: boolean): void {
         let node: ts.Node = labelTarget.getCorrespondingNode();
         let loopEnvLevel = labelTarget.getLoopEnvLevel();
         switch (node.kind) {
@@ -553,7 +553,7 @@ export class Compiler {
         }
     }
 
-    private compileContinueStatement(stmt: ts.ContinueStatement) {
+    private compileContinueStatement(stmt: ts.ContinueStatement): void {
         let continueLabelTarget = LabelTarget.getLabelTarget(stmt);
 
         this.compileFinallyBeforeCFC(
@@ -570,7 +570,7 @@ export class Compiler {
         this.pandaGen.branch(stmt, continueLabelTarget.getContinueTargetLabel()!);
     }
 
-    private compileBreakStatement(stmt: ts.BreakStatement) {
+    private compileBreakStatement(stmt: ts.BreakStatement): void {
         let breakLabelTarget = LabelTarget.getLabelTarget(stmt);
 
         this.compileFinallyBeforeCFC(
@@ -587,13 +587,13 @@ export class Compiler {
         this.pandaGen.branch(stmt, breakLabelTarget.getBreakTargetLabel());
     }
 
-    private compileLabeledStatement(stmt: ts.LabeledStatement) {
+    private compileLabeledStatement(stmt: ts.LabeledStatement): void {
         this.pushScope(stmt);
         let labelName: string = jshelpers.getTextOfIdentifierOrLiteral(stmt.label);
         let blockEndLabel = undefined;
 
         // because there is no label in the block/if statement, we need to add the end label.
-        if (stmt.statement.kind == ts.SyntaxKind.Block || stmt.statement.kind == ts.SyntaxKind.IfStatement) {
+        if (stmt.statement.kind === ts.SyntaxKind.Block || stmt.statement.kind === ts.SyntaxKind.IfStatement) {
             blockEndLabel = new Label();
 
             let labelTarget = new LabelTarget(stmt, blockEndLabel, undefined);
@@ -612,7 +612,7 @@ export class Compiler {
         this.popScope();
     }
 
-    private compileThrowStatement(stmt: ts.ThrowStatement) {
+    private compileThrowStatement(stmt: ts.ThrowStatement): void {
         let pandaGen = this.pandaGen;
         if (stmt.expression) {
             this.compileExpression(stmt.expression);
@@ -627,7 +627,8 @@ export class Compiler {
         pandaGen.throw(stmt);
     }
 
-    compileFinallyBeforeCFC(endTry: TryStatement | undefined, cfc: ControlFlowChange, continueTargetLabel: Label | undefined) {// compile finally before control flow change
+    // compile finally before control flow change
+    compileFinallyBeforeCFC(endTry: TryStatement | undefined, cfc: ControlFlowChange, continueTargetLabel: Label | undefined): void {
         let startTry = TryStatement.getCurrentTryStatement();
         let originTry = startTry;
         let currentScope = this.scope;
@@ -639,7 +640,7 @@ export class Compiler {
                 let inlinedLabelPair = new LabelPair(inlineFinallyBegin, inlineFinallyEnd);
                 // adjust the current tryStatement before inlining finallyBlock
                 let saveTry = TryStatement.getCurrentTryStatement();
-                TryStatement.setCurrentTryStatement(startTry.getOuterTryStatement())
+                TryStatement.setCurrentTryStatement(startTry.getOuterTryStatement());
 
                 this.pandaGen.label(startTry.getStatement(), inlineFinallyBegin);
                 startTry.trybuilder.compileFinalizer(cfc, continueTargetLabel);
@@ -673,7 +674,7 @@ export class Compiler {
         this.scope = currentScope;
     }
 
-    constructTry(node: ts.Node, tryBuilder: TryBuilderBase, endLabel?: Label) {
+    constructTry(node: ts.Node, tryBuilder: TryBuilderBase, endLabel?: Label): void {
         let pandaGen = this.pandaGen;
         let tryBeginLabel = new Label();
         let tryEndLabel = new Label();
@@ -709,7 +710,7 @@ export class Compiler {
         }
     }
 
-    private compileTryStatement(stmt: ts.TryStatement) {
+    private compileTryStatement(stmt: ts.TryStatement): void {
         this.pushScope(stmt);
         // try-catch-finally statements must have been transformed into
         // two nested try statements with only "catch" or "finally" each.
@@ -722,7 +723,7 @@ export class Compiler {
         this.popScope();
     }
 
-    private compileFunctionDeclaration(decl: ts.FunctionDeclaration) {
+    private compileFunctionDeclaration(decl: ts.FunctionDeclaration): void {
         if (!decl.name) {
             if (hasExportKeywordModifier(decl) && this.scope instanceof ModuleScope) {
                 return;
@@ -731,15 +732,15 @@ export class Compiler {
         }
     }
 
-    private compileExportAssignment(stmt: ts.ExportAssignment) {
+    private compileExportAssignment(stmt: ts.ExportAssignment): void {
         this.compileExpression(stmt.expression);
         let defaultV: ModuleVariable = <ModuleVariable>(this.pandaGen.getScope().findLocal("*default*"));
         this.pandaGen.storeModuleVariable(stmt, defaultV);
     }
 
-    compileCondition(expr: ts.Expression, ifFalseLabel: Label) {
+    compileCondition(expr: ts.Expression, ifFalseLabel: Label): void {
         let pandaGen = this.pandaGen;
-        if (expr.kind == ts.SyntaxKind.BinaryExpression) {
+        if (expr.kind === ts.SyntaxKind.BinaryExpression) {
             let binExpr = <ts.BinaryExpression>expr;
 
             switch (binExpr.operatorToken.kind) {
@@ -790,7 +791,7 @@ export class Compiler {
         pandaGen.jumpIfFalse(expr, ifFalseLabel);
     }
 
-    compileExpression(expr: ts.Expression) {
+    compileExpression(expr: ts.Expression): void {
         // Please keep order of cases the same as in types.ts
         LOGD(this.debugTag, "compile expr: " + ts.SyntaxKind[expr.kind] + " " + expr.kind);
         switch (expr.kind) {
@@ -817,7 +818,7 @@ export class Compiler {
                 compileCallExpression(<ts.CallExpression>expr, this);
                 break;
             case ts.SyntaxKind.NullKeyword: // line 135
-                this.pandaGen.loadAccumulator(expr, getVregisterCache(this.pandaGen, CacheList.Null));
+                this.pandaGen.loadAccumulator(expr, getVregisterCache(this.pandaGen, CacheList.NULL));
                 break;
             case ts.SyntaxKind.ThisKeyword: // line 139
                 this.compileThisKeyword(expr);
@@ -903,7 +904,7 @@ export class Compiler {
         }
     }
 
-    private compileIdentifier(id: ts.Identifier) {
+    private compileIdentifier(id: ts.Identifier): void {
         let name = jshelpers.getTextOfIdentifierOrLiteral(id);
         let { scope, level, v } = this.scope.find(name);
         if (!v) {
@@ -915,30 +916,30 @@ export class Compiler {
         }
     }
 
-    private compileUnscopedIdentifier(id: ts.Identifier) {
+    private compileUnscopedIdentifier(id: ts.Identifier): void {
         let name = jshelpers.getTextOfIdentifierOrLiteral(id);
         let pandaGen = this.pandaGen;
         switch (name) {
             // Those identifier are Built-In value properties
             case "NaN":
-                pandaGen.loadAccumulator(id, getVregisterCache(this.pandaGen, CacheList.NaN));
+                pandaGen.loadAccumulator(id, getVregisterCache(this.pandaGen, CacheList.NAN));
                 return;
             case "Infinity":
-                pandaGen.loadAccumulator(id, getVregisterCache(this.pandaGen, CacheList.Infinity));
+                pandaGen.loadAccumulator(id, getVregisterCache(this.pandaGen, CacheList.INFINITY));
                 return;
             case "globalThis":
-                pandaGen.loadAccumulator(id, getVregisterCache(this.pandaGen, CacheList.Global));
+                pandaGen.loadAccumulator(id, getVregisterCache(this.pandaGen, CacheList.GLOBAL));
                 return;
             case "undefined":
-                pandaGen.loadAccumulator(id, getVregisterCache(this.pandaGen, CacheList.undefined));
+                pandaGen.loadAccumulator(id, getVregisterCache(this.pandaGen, CacheList.UNDEFINED));
                 return;
             default: {
                 // typeof an undeclared variable will return undefined instead of throwing reference error
                 let parent = findOuterNodeOfParenthesis(id);
-                if ((parent.kind == ts.SyntaxKind.TypeOfExpression)) {
+                if ((parent.kind === ts.SyntaxKind.TypeOfExpression)) {
                     CmdOptions.isWatchEvaluateExpressionMode() ?
-                        pandaGen.loadByNameViaDebugger(id, name, CacheList.False) :
-                        pandaGen.loadObjProperty(id, getVregisterCache(pandaGen, CacheList.Global), name);
+                        pandaGen.loadByNameViaDebugger(id, name, CacheList.FALSE) :
+                        pandaGen.loadObjProperty(id, getVregisterCache(pandaGen, CacheList.GLOBAL), name);
                 } else {
                     pandaGen.tryLoadGlobalByName(id, name);
                 }
@@ -947,28 +948,28 @@ export class Compiler {
         }
     }
 
-    private compileBooleanLiteral(lit: ts.BooleanLiteral) {
-        if (lit.kind == ts.SyntaxKind.TrueKeyword) {
-            this.pandaGen.loadAccumulator(lit, getVregisterCache(this.pandaGen, CacheList.True));
+    private compileBooleanLiteral(lit: ts.BooleanLiteral): void {
+        if (lit.kind === ts.SyntaxKind.TrueKeyword) {
+            this.pandaGen.loadAccumulator(lit, getVregisterCache(this.pandaGen, CacheList.TRUE));
         } else {
-            this.pandaGen.loadAccumulator(lit, getVregisterCache(this.pandaGen, CacheList.False));
+            this.pandaGen.loadAccumulator(lit, getVregisterCache(this.pandaGen, CacheList.FALSE));
         }
     }
 
     compileFunctionReturnThis(expr: ts.NewExpression | ts.CallExpression): boolean {
-        if (expr.expression.kind == ts.SyntaxKind.Identifier) {
+        if (expr.expression.kind === ts.SyntaxKind.Identifier) {
             let identifier = <ts.Identifier>expr.expression;
             let args = expr.arguments;
-            if (identifier.escapedText == "Function") {
+            if (identifier.escapedText === "Function") {
                 if (args && args.length > 0) {
                     if (!ts.isStringLiteral(args[args.length - 1])) {
                         return false;
                     }
                     let arg = <ts.StringLiteral>args[args.length - 1];
-                    if (arg.text.match(/ *return +this[;]? *$/) == null) {
+                    if (arg.text.match(/ *return +this[;]? *$/) === null) {
                         return false;
                     } else {
-                        this.pandaGen.loadAccumulator(expr, getVregisterCache(this.pandaGen, CacheList.Global))
+                        this.pandaGen.loadAccumulator(expr, getVregisterCache(this.pandaGen, CacheList.GLOBAL));
                         return true;
                     }
                 }
@@ -977,7 +978,7 @@ export class Compiler {
         return false;
     }
 
-    private compileThisKeyword(node: ts.Node) {
+    private compileThisKeyword(node: ts.Node): void {
         let pandaGen = this.pandaGen;
 
         checkValidUseSuperBeforeSuper(this, node);
@@ -990,7 +991,7 @@ export class Compiler {
 
         if (v instanceof LocalVariable) {
             if (CmdOptions.isWatchEvaluateExpressionMode()) {
-                pandaGen.loadByNameViaDebugger(node, MandatoryThis, CacheList.True);
+                pandaGen.loadByNameViaDebugger(node, MandatoryThis, CacheList.TRUE);
                 return;
             }
 
@@ -1001,12 +1002,12 @@ export class Compiler {
         throw new Error("\"this\" must be a local variable");
     }
 
-    private compileFunctionExpression(expr: ts.FunctionExpression) {
+    private compileFunctionExpression(expr: ts.FunctionExpression): void {
         let internalName = this.compilerDriver.getFuncInternalName(expr, this.recorder);
         this.pandaGen.defineFunction(expr, expr, internalName);
     }
 
-    private compileDeleteExpression(expr: ts.DeleteExpression) {
+    private compileDeleteExpression(expr: ts.DeleteExpression): void {
         let pandaGen = this.pandaGen;
         let objReg: VReg;
         let propReg: VReg;
@@ -1020,13 +1021,13 @@ export class Compiler {
                 if (!v || ((scope instanceof GlobalScope) && (v instanceof GlobalVariable))) {
                     // If the variable doesn't exist or if it is global, we must generate
                     // a delete global property instruction.
-                    objReg = getVregisterCache(pandaGen, CacheList.Global);
+                    objReg = getVregisterCache(pandaGen, CacheList.GLOBAL);
                     pandaGen.loadAccumulatorString(unaryExpr, name);
                     pandaGen.deleteObjProperty(expr, objReg);
                 } else {
                     // Otherwise it is a local variable which can't be deleted and we just
                     // return false.
-                    pandaGen.loadAccumulator(unaryExpr, getVregisterCache(pandaGen, CacheList.False));
+                    pandaGen.loadAccumulator(unaryExpr, getVregisterCache(pandaGen, CacheList.FALSE));
                 }
                 break;
             }
@@ -1062,26 +1063,26 @@ export class Compiler {
                 // compile the delete operand.
                 this.compileExpression(unaryExpr);
                 // Deleting any value or a result of an expression returns True.
-                pandaGen.loadAccumulator(expr, getVregisterCache(pandaGen, CacheList.True));
+                pandaGen.loadAccumulator(expr, getVregisterCache(pandaGen, CacheList.TRUE));
             }
         }
     }
 
-    private compileTypeOfExpression(expr: ts.TypeOfExpression) {
+    private compileTypeOfExpression(expr: ts.TypeOfExpression): void {
         // expr -> acc
         this.compileExpression(expr.expression);
         this.pandaGen.typeOf(expr);
     }
 
-    private compileVoidExpression(expr: ts.VoidExpression) {
+    private compileVoidExpression(expr: ts.VoidExpression): void {
         let pandaGen = this.pandaGen;
         // compileExpression() must be called even though its value is not used
         // because it may have observable sideeffects.
         this.compileExpression(expr.expression);
-        pandaGen.loadAccumulator(expr, getVregisterCache(pandaGen, CacheList.undefined));
+        pandaGen.loadAccumulator(expr, getVregisterCache(pandaGen, CacheList.UNDEFINED));
     }
 
-    private compileAwaitExpression(expr: ts.AwaitExpression) {
+    private compileAwaitExpression(expr: ts.AwaitExpression): void {
         let pandaGen = this.pandaGen;
 
         if (!(this.funcBuilder instanceof AsyncFunctionBuilder || this.funcBuilder instanceof AsyncGeneratorFunctionBuilder)) {
@@ -1092,12 +1093,12 @@ export class Compiler {
             this.compileExpression(expr.expression);
             this.funcBuilder.await(expr);
         } else {
-            pandaGen.loadAccumulator(expr, getVregisterCache(pandaGen, CacheList.undefined));
+            pandaGen.loadAccumulator(expr, getVregisterCache(pandaGen, CacheList.UNDEFINED));
             this.funcBuilder.await(expr);
         }
     }
 
-    private compilePrefixUnaryExpression(expr: ts.PrefixUnaryExpression) {
+    private compilePrefixUnaryExpression(expr: ts.PrefixUnaryExpression): void {
         let pandaGen = this.pandaGen;
         let operandReg = pandaGen.getTemp();
         // acc -> op(acc)
@@ -1127,7 +1128,7 @@ export class Compiler {
         pandaGen.freeTemps(operandReg);
     }
 
-    private compilePostfixUnaryExpression(expr: ts.PostfixUnaryExpression) {
+    private compilePostfixUnaryExpression(expr: ts.PostfixUnaryExpression): void {
         let pandaGen = this.pandaGen;
         let operandReg = pandaGen.getTemp();
         // expr -> acc
@@ -1151,7 +1152,7 @@ export class Compiler {
         pandaGen.freeTemps(operandReg);
     }
 
-    private compileLogicalExpression(expr: ts.BinaryExpression) {
+    private compileLogicalExpression(expr: ts.BinaryExpression): void {
         let pandaGen = this.pandaGen;
         let lhs = pandaGen.getTemp();
         switch (expr.operatorToken.kind) {
@@ -1200,10 +1201,10 @@ export class Compiler {
                 this.compileExpression(expr.left);
                 pandaGen.storeAccumulator(expr, lhs);
                 // equality comparasion between lhs and null, if true, load right
-                pandaGen.condition(expr, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.Null), leftNullishLabel);
+                pandaGen.condition(expr, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.NULL), leftNullishLabel);
                 // equality comparasion between lhs and undefined, if true, load right
                 pandaGen.loadAccumulator(expr.left, lhs);
-                pandaGen.condition(expr, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.undefined), leftNullishLabel);
+                pandaGen.condition(expr, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.UNDEFINED), leftNullishLabel);
                 // lhs is either null or undefined, load left
                 pandaGen.loadAccumulator(expr, lhs);
                 pandaGen.branch(expr, endLabel);
@@ -1218,15 +1219,15 @@ export class Compiler {
         pandaGen.freeTemps(lhs);
     }
 
-    private compileBinaryExpression(expr: ts.BinaryExpression) {
+    private compileBinaryExpression(expr: ts.BinaryExpression): void {
         if (isAssignmentOperator(expr.operatorToken.kind)) {
             this.compileAssignmentExpression(expr.left, expr.right, <AssignmentOperator>expr.operatorToken.kind);
             return;
         }
         // LogicAnd, LogicOr and Coalesce are Short-circuiting
-        if (expr.operatorToken.kind == ts.SyntaxKind.AmpersandAmpersandToken
-            || expr.operatorToken.kind == ts.SyntaxKind.BarBarToken
-            || expr.operatorToken.kind == ts.SyntaxKind.QuestionQuestionToken) {
+        if (expr.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+            expr.operatorToken.kind === ts.SyntaxKind.BarBarToken ||
+            expr.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
             this.compileLogicalExpression(expr);
             return;
         }
@@ -1244,7 +1245,7 @@ export class Compiler {
         pandaGen.freeTemps(lhs);
     }
 
-    private compileConditionalExpression(expr: ts.ConditionalExpression) {
+    private compileConditionalExpression(expr: ts.ConditionalExpression): void {
         let falseLabel = new Label();
         let endLabel = new Label();
 
@@ -1256,12 +1257,12 @@ export class Compiler {
         this.pandaGen.label(expr, endLabel);
     }
 
-    private compileArrowFunction(expr: ts.ArrowFunction) {
+    private compileArrowFunction(expr: ts.ArrowFunction): void {
         let internalName = this.compilerDriver.getFuncInternalName(expr, this.recorder);
         this.pandaGen.defineFunction(expr, expr, internalName);
     }
 
-    private compileTemplateSpan(expr: ts.TemplateSpan) {
+    private compileTemplateSpan(expr: ts.TemplateSpan): void {
         let span = expr.expression;
         this.compileExpression(span);
         let literal = expr.literal;
@@ -1277,7 +1278,7 @@ export class Compiler {
         this.pandaGen.freeTemps(lrh);
     }
 
-    private compileTemplateExpression(expr: ts.TemplateExpression) {
+    private compileTemplateExpression(expr: ts.TemplateExpression): void {
         let pandaGen = this.pandaGen;
         let head = expr.head;
         let spans = expr.templateSpans;
@@ -1296,12 +1297,12 @@ export class Compiler {
         pandaGen.freeTemps(lrh);
     }
 
-    private compileNoSubstitutionTemplateLiteral(expr: ts.NoSubstitutionTemplateLiteral) {
+    private compileNoSubstitutionTemplateLiteral(expr: ts.NoSubstitutionTemplateLiteral): void {
         let text = expr.text;
         this.pandaGen.loadAccumulatorString(expr, text);
     }
 
-    private compileTaggedTemplateExpression(expr: ts.TaggedTemplateExpression) {
+    private compileTaggedTemplateExpression(expr: ts.TaggedTemplateExpression): void {
         let pandaGen = this.pandaGen;
         let spans = undefined;
         if (ts.isTemplateExpression(expr.template)) {
@@ -1311,7 +1312,7 @@ export class Compiler {
         let { arguments: argRegs, passThis: passThis } = getHiddenParameters(expr.tag, this); // +3 for function and this
         getTemplateObject(pandaGen, expr);
         let templateObj = pandaGen.getTemp();
-        pandaGen.storeAccumulator(expr, templateObj)
+        pandaGen.storeAccumulator(expr, templateObj);
         argRegs.push(templateObj);
 
         if (spans && spans.length) {
@@ -1329,7 +1330,7 @@ export class Compiler {
         return;
     }
 
-    private compileAssignmentExpression(lhs: ts.Expression, rhs: ts.Expression, operator: AssignmentOperator) {
+    private compileAssignmentExpression(lhs: ts.Expression, rhs: ts.Expression, operator: AssignmentOperator): void {
         let lref = LReference.generateLReference(this, lhs, false);
 
         if (operator != ts.SyntaxKind.EqualsToken) {
@@ -1347,14 +1348,14 @@ export class Compiler {
         lref.setValue();
     }
 
-    pushScope(node: ts.Node) {
+    pushScope(node: ts.Node): void {
         let scope = <Scope>this.recorder.getScopeOfNode(node);
         this.scope = scope;
         // for debug info
         DebugInfo.addDebugIns(scope, this.pandaGen, true);
     }
 
-    popScope() {
+    popScope(): void {
         // for debug info
         DebugInfo.addDebugIns(this.scope, this.pandaGen, false);
         this.scope = <Scope>this.scope.getParent();
@@ -1364,7 +1365,7 @@ export class Compiler {
         return ts.SyntaxKind[node.kind];
     }
 
-    getThis(node: ts.Node, res: VReg) {
+    getThis(node: ts.Node, res: VReg): void {
         let pandaGen = this.pandaGen;
         let thisInfo = this.getCurrentScope().find(MandatoryThis);
         let level = thisInfo.level;
@@ -1379,7 +1380,7 @@ export class Compiler {
         }
     }
 
-    setThis(node: ts.Node) {
+    setThis(node: ts.Node): void {
         let pandaGen = this.pandaGen;
         let thisInfo = this.getCurrentScope().find(MandatoryThis);
 
@@ -1390,33 +1391,33 @@ export class Compiler {
             pandaGen.storeLexicalVar(node, thisInfo.level, slot, value);
             pandaGen.freeTemps(value);
         } else {
-            pandaGen.storeAccumulator(node, pandaGen.getVregForVariable(<Variable>thisInfo.v))
+            pandaGen.storeAccumulator(node, pandaGen.getVregForVariable(<Variable>thisInfo.v));
         }
     }
 
-    getPandaGen() {
+    getPandaGen(): PandaGen {
         return this.pandaGen;
     }
 
-    getCurrentScope() {
+    getCurrentScope(): Scope {
         return this.scope;
     }
 
-    getCompilerDriver() {
+    getCompilerDriver(): CompilerDriver {
         return this.compilerDriver;
     }
 
-    getRecorder() {
+    getRecorder(): Recorder {
         return this.recorder;
     }
 
-    getFuncBuilder() {
+    getFuncBuilder(): FunctionBuilder {
         return this.funcBuilder;
     }
 
     storeTarget(node: ts.Node,
         variable: { scope: Scope | undefined, level: number, v: Variable | undefined },
-        isDeclaration: boolean) {
+        isDeclaration: boolean): void {
         if (variable.v instanceof LocalVariable) {
             if (isDeclaration && variable.v.isLetOrConst()) {
                 variable.v.initialize();
@@ -1472,7 +1473,7 @@ export class Compiler {
         }
     }
 
-    loadTarget(node: ts.Node, variable: { scope: Scope | undefined, level: number, v: Variable | undefined }) {
+    loadTarget(node: ts.Node, variable: { scope: Scope | undefined, level: number, v: Variable | undefined }): void {
         if (variable.v instanceof LocalVariable) {
             if (!CmdOptions.isCommonJs() && (variable.v.isLetOrConst() || variable.v.isClass())) {
                 if (variable.scope instanceof GlobalScope) {
@@ -1485,10 +1486,10 @@ export class Compiler {
         } else if (variable.v instanceof GlobalVariable) {
             if (variable.v.isNone()) {
                 let parent = findOuterNodeOfParenthesis(node);
-                if ((parent.kind == ts.SyntaxKind.TypeOfExpression)) {
+                if ((parent.kind === ts.SyntaxKind.TypeOfExpression)) {
                     CmdOptions.isWatchEvaluateExpressionMode() ?
-                        this.pandaGen.loadByNameViaDebugger(node, variable.v.getName(), CacheList.False) :
-                        this.pandaGen.loadObjProperty(node, getVregisterCache(this.pandaGen, CacheList.Global),
+                        this.pandaGen.loadByNameViaDebugger(node, variable.v.getName(), CacheList.FALSE) :
+                        this.pandaGen.loadObjProperty(node, getVregisterCache(this.pandaGen, CacheList.GLOBAL),
                         variable.v.getName());
                 } else {
                     this.pandaGen.tryLoadGlobalByName(node, variable.v.getName());
diff --git a/ts2panda/src/compilerDriver.ts b/ts2panda/src/compilerDriver.ts
index ca2e9f1f62..6cfc16f47a 100644
--- a/ts2panda/src/compilerDriver.ts
+++ b/ts2panda/src/compilerDriver.ts
@@ -95,7 +95,7 @@ export class CompilerDriver {
         }
     }
 
-    initiateTs2abcChildProcess(args: Array<string>) {
+    initiateTs2abcChildProcess(args: Array<string>): void {
         this.ts2abcProcess = initiateTs2abc(args);
         listenChildExit(this.getTs2abcProcess());
         listenErrorEvent(this.getTs2abcProcess());
@@ -103,16 +103,16 @@ export class CompilerDriver {
 
     getTs2abcProcess(): any {
         if (this.ts2abcProcess === undefined) {
-            throw new Error("ts2abc hasn't been initiated")
+            throw new Error("ts2abc hasn't been initiated");
         }
         return this.ts2abcProcess;
     }
 
-    getStatistics() {
+    getStatistics(): CompilerStatistics {
         return this.statistics;
     }
 
-    setCustomPasses(passes: Pass[]) {
+    setCustomPasses(passes: Pass[]): void {
         this.passes = passes;
     }
 
@@ -124,15 +124,15 @@ export class CompilerDriver {
         return internalName;
     }
 
-    getCompilationUnits() {
+    getCompilationUnits(): PandaGen[] {
         return this.compilationUnits;
     }
 
-    kind2String(kind: ts.SyntaxKind) {
+    kind2String(kind: ts.SyntaxKind): string {
         return ts.SyntaxKind[kind];
     }
 
-    getASTStatistics(node: ts.Node, statics: number[]) {
+    getASTStatistics(node: ts.Node, statics: number[]): void {
         node.forEachChild(childNode => {
             statics[<number>childNode.kind] = statics[<number>childNode.kind] + 1;
             this.getASTStatistics(childNode, statics);
@@ -147,7 +147,7 @@ export class CompilerDriver {
         stack.push(scope);
         while (stack.length > 0) {
             let temp: VariableScope | undefined = stack.pop();
-            if (temp == undefined) {
+            if (temp === undefined) {
                 break;
             }
             spArray.push(temp);
@@ -306,7 +306,7 @@ export class CompilerDriver {
     }
 
     private compileUnitTestImpl(node: ts.SourceFile | ts.FunctionLikeDeclaration, scope: Scope,
-        internalName: string, recorder: Recorder) {
+        internalName: string, recorder: Recorder): void {
         let pandaGen = new PandaGen(internalName, node, this.getParametersCount(node), scope);
         IRNode.pg = pandaGen;
         if (CmdOptions.needRecordSourceCode() && !ts.isSourceFile(node)) {
@@ -323,7 +323,7 @@ export class CompilerDriver {
         this.compilationUnits.push(pandaGen);
     }
 
-    static isTypeScriptSourceFile(node: ts.SourceFile) {
+    static isTypeScriptSourceFile(node: ts.SourceFile): boolean {
         let fileName = node.fileName;
         if (fileName && fileName.endsWith(".ts")) {
             return true;
@@ -332,7 +332,7 @@ export class CompilerDriver {
         }
     }
 
-    private compilePrologue(node: ts.SourceFile, recordType: boolean, syntaxCheckStatus: boolean) {
+    private compilePrologue(node: ts.SourceFile, recordType: boolean, syntaxCheckStatus: boolean): Recorder {
         let topLevelScope: GlobalScope | ModuleScope;
         if (CmdOptions.isModules()) {
             topLevelScope = new ModuleScope(node);
@@ -386,7 +386,7 @@ export class CompilerDriver {
         return idx;
     }
 
-    getFormatedRecordName() {
+    getFormatedRecordName(): string {
         let formatedRecordName: string = '';
         if (CmdOptions.isMergeAbc()) {
             formatedRecordName = this.recordName + '.';
@@ -408,15 +408,15 @@ export class CompilerDriver {
         } else {
             let funcNode = <ts.FunctionLikeDeclaration>node;
             name = (<FunctionScope>recorder.getScopeOfNode(funcNode)).getFuncName();
-            if (name == '') {
-                if ((ts.isFunctionDeclaration(node) && hasExportKeywordModifier(node) && hasDefaultKeywordModifier(node))
-                    || ts.isExportAssignment(findOuterNodeOfParenthesis(node))) {
+            if (name === '') {
+                if ((ts.isFunctionDeclaration(node) && hasExportKeywordModifier(node) && hasDefaultKeywordModifier(node)) ||
+                    ts.isExportAssignment(findOuterNodeOfParenthesis(node))) {
                     return `${this.getFormatedRecordName()}default`;
                 }
                 return `${this.getFormatedRecordName()}#${this.getFuncId(funcNode)}#`;
             }
 
-            if (name == "func_main_0") {
+            if (name === "func_main_0") {
                 return `${this.getFormatedRecordName()}#${this.getFuncId(funcNode)}#${name}`;
             }
 
@@ -431,22 +431,22 @@ export class CompilerDriver {
             }
 
             if (name.lastIndexOf(".") != -1 || name.lastIndexOf("\\") != -1) {
-                name = `#${this.getFuncId(funcNode)}#`
+                name = `#${this.getFuncId(funcNode)}#`;
             }
         }
         return `${this.getFormatedRecordName()}${name}`;
     }
 
-    getInternalNameForCtor(node: ts.ClassLikeDeclaration, ctor: ts.ConstructorDeclaration) {
+    getInternalNameForCtor(node: ts.ClassLikeDeclaration, ctor: ts.ConstructorDeclaration): string {
         let name = getClassNameForConstructor(node);
-        name = `#${this.getFuncId(ctor)}#${name}`
+        name = `#${this.getFuncId(ctor)}#${name}`;
         if (name.lastIndexOf(".") != -1) {
-            name = `#${this.getFuncId(ctor)}#`
+            name = `#${this.getFuncId(ctor)}#`;
         }
         return `${this.getFormatedRecordName()}${name}`;
     }
 
-    writeBinaryFile(pandaGen: PandaGen) {
+    writeBinaryFile(pandaGen: PandaGen): void {
         if (this.needDumpHeader) {
             AssemblyDumper.dumpHeader();
             this.needDumpHeader = false;
@@ -458,7 +458,7 @@ export class CompilerDriver {
         // each function and global scope accepts three parameters - funcObj + newTarget + this.
         // the runtime passes these to global scope when calls it
         let parametersCount = 3;
-        if (node.kind == ts.SyntaxKind.SourceFile) {
+        if (node.kind === ts.SyntaxKind.SourceFile) {
             if (CmdOptions.isCommonJs()) {
                 // global scope accepts 5 additional parameters:
                 // "exports", "require", "module", "__filename","__dirname"
@@ -472,13 +472,13 @@ export class CompilerDriver {
         return parametersCount;
     }
 
-    private setTypeInfoBeforeRecord(enableTypeRecord: boolean) {
+    private setTypeInfoBeforeRecord(enableTypeRecord: boolean): void {
         if (enableTypeRecord) {
             TypeRecorder.createInstance();
         }
     }
 
-    private setTypeInfoAfterRecord(enableTypeRecord: boolean) {
+    private setTypeInfoAfterRecord(enableTypeRecord: boolean): void {
         if (enableTypeRecord) {
             TypeRecorder.getInstance().setTypeSummary();
             if (CmdOptions.enableTypeLog()) {
diff --git a/ts2panda/src/compilerStatistics.ts b/ts2panda/src/compilerStatistics.ts
index e94a3e1543..1384738242 100644
--- a/ts2panda/src/compilerStatistics.ts
+++ b/ts2panda/src/compilerStatistics.ts
@@ -37,37 +37,37 @@ class ItemValue {
         }
     }
 
-    add(num: number) {
+    add(num: number): void {
         this.count += num;
         this.relatedInsns.forEach(relatedInsn => { relatedInsn.num += num });
     }
 
-    set(num: number) {
+    set(num: number): void {
         this.count = num;
         this.relatedInsns.forEach(relatedInsn => { relatedInsn.num = num });
     }
 
-    getCount() {
+    getCount(): number {
         return this.count;
     }
 
-    getInstSize() {
+    getInstSize(): number {
         return this.instSize;
     }
 
-    getTotalSize() {
+    getTotalSize(): number {
         return this.count * this.instSize;
     }
 
-    getRelatedInsns() {
+    getRelatedInsns(): { name: string, num: number }[] {
         return this.relatedInsns;
     }
 
-    getNodeMap() {
+    getNodeMap(): Map<string, number> {
         return this.nodeMap;
     }
 
-    updateNodeMap(nodeName: string) {
+    updateNodeMap(nodeName: string): void {
         if (!this.nodeMap.has(nodeName)) {
             this.nodeMap.set(nodeName, 1);
         } else {
@@ -76,7 +76,7 @@ class ItemValue {
         }
     }
 
-    unionNodeMap(nodeMap: Map<string, number>) {
+    unionNodeMap(nodeMap: Map<string, number>): void {
         nodeMap.forEach((value: number, key: string) => {
             if (!this.nodeMap.has(key)) {
                 this.nodeMap.set(key, value);
@@ -88,7 +88,7 @@ class ItemValue {
         });
     }
 
-    getSavedSizeIfRemoved(Histogram: HistogramStatistics) {
+    getSavedSizeIfRemoved(Histogram: HistogramStatistics): number {
         let savedSize = this.getTotalSize();
         this.relatedInsns.forEach(relatedInsn => {
             let histogram = Histogram.getStatistics();
@@ -103,7 +103,7 @@ class ItemValue {
 
     static createItemValue(name: string, instSize: number): ItemValue {
         let relatedInsns: { name: string, num: number };
-        if (name == "lda.str") {
+        if (name === "lda.str") {
             relatedInsns = { name: "sta.dyn", num: 1 };
         }
 
@@ -120,8 +120,8 @@ class HistogramStatistics {
     }
 
     getInsName(ins: IRNode): string {
-        if (ins.kind == IRNodeKind.LABEL) {
-            return "Label"
+        if (ins.kind === IRNodeKind.LABEL) {
+            return "Label";
         }
 
         return ins.getMnemonic();
@@ -167,7 +167,7 @@ class HistogramStatistics {
         return this.insHistogram;
     }
 
-    getTotal() {
+    getTotal(): number[] {
         let totalInsnsNum: number = 0;
         let totalSize: number = 0;
         // @ts-ignore
@@ -187,14 +187,15 @@ class HistogramStatistics {
         LOGD("op code\t\t\tinsns number\tins size\ttotal size\tsize percentage");
         this.insHistogram.forEach((value, key) => {
             if (key.length < 8) { // 8 indicates insn name length
-                LOGD(key + "\t\t\t" + value.getCount() + "\t\t"+ value.getInstSize() + "\t\t" + value.getTotalSize() + "\t\t"
-                     + value.getSavedSizeIfRemoved(this) + "\t" + Math.round(value.getSavedSizeIfRemoved(this) / totalSize * 100) + "%"); // multiplying 100 is to calculate percentage data
+                // multiplying 100 is to calculate percentage data
+                LOGD(key + "\t\t\t" + value.getCount() + "\t\t"+ value.getInstSize() + "\t\t" + value.getTotalSize() + "\t\t" +
+                     value.getSavedSizeIfRemoved(this) + "\t" + Math.round(value.getSavedSizeIfRemoved(this) / totalSize * 100) + "%");
             } else if (key.length < 16) { // 16 indicates insn name length
-                LOGD(key + "\t\t" + value.getCount() + "\t\t" + value.getInstSize() + "\t\t" + value.getTotalSize() + "\t\t"
-                     + value.getSavedSizeIfRemoved(this) + "\t" + Math.round(value.getSavedSizeIfRemoved(this) / totalSize * 100) + "%");
+                LOGD(key + "\t\t" + value.getCount() + "\t\t" + value.getInstSize() + "\t\t" + value.getTotalSize() + "\t\t" +
+                     value.getSavedSizeIfRemoved(this) + "\t" + Math.round(value.getSavedSizeIfRemoved(this) / totalSize * 100) + "%");
             } else {
-                LOGD(key + "\t" + value.getCount() + "\t\t" + value.getInstSize() + "\t\t" + value.getTotalSize() + "\t\t"
-                     + value.getSavedSizeIfRemoved(this) + "\t" + Math.round(value.getSavedSizeIfRemoved(this) / totalSize * 100) + "%");
+                LOGD(key + "\t" + value.getCount() + "\t\t" + value.getInstSize() + "\t\t" + value.getTotalSize() + "\t\t" +
+                     value.getSavedSizeIfRemoved(this) + "\t" + Math.round(value.getSavedSizeIfRemoved(this) / totalSize * 100) + "%");
             }
         });
 
@@ -231,22 +232,22 @@ export class CompilerStatistics {
 
     }
 
-    addHoistingRelatedInsnNum(num: number) {
+    addHoistingRelatedInsnNum(num: number): void {
         this.hoistingRelatedInsnNum += num;
     }
 
-    addNumOfHoistCases(type: HoistingType) {
+    addNumOfHoistCases(type: HoistingType): void {
         this.numOfHoistingCases[type]++;
     }
 
-    getInsHistogramStatistics(pg: PandaGen) {
+    getInsHistogramStatistics(pg: PandaGen): void {
         let histogram = new HistogramStatistics(pg.internalName);
 
         histogram.catchStatistics(pg);
         this.histogramMap.set(pg.internalName, histogram);
     }
 
-    printHistogram(verbose: boolean) {
+    printHistogram(verbose: boolean): void {
         let totalHistogram = new HistogramStatistics("Total");
         
         // @ts-ignore
diff --git a/ts2panda/src/compilerUtils.ts b/ts2panda/src/compilerUtils.ts
index 1d406d114b..c16e65f30b 100644
--- a/ts2panda/src/compilerUtils.ts
+++ b/ts2panda/src/compilerUtils.ts
@@ -36,7 +36,7 @@ import {
 } from "./statement/tryStatement";
 import { Iterator } from "./base/iterator";
 
-export function compileDestructuring(pattern: ts.BindingOrAssignmentPattern, pandaGen: PandaGen, compiler: Compiler) {
+export function compileDestructuring(pattern: ts.BindingOrAssignmentPattern, pandaGen: PandaGen, compiler: Compiler): void {
     let rhs = pandaGen.getTemp();
     pandaGen.storeAccumulator(pattern, rhs);
 
@@ -52,7 +52,7 @@ export function compileDestructuring(pattern: ts.BindingOrAssignmentPattern, pan
     pandaGen.freeTemps(rhs);
 }
 
-function compileArrayDestructuring(arr: ts.ArrayBindingOrAssignmentPattern, pandaGen: PandaGen, compiler: Compiler) {
+function compileArrayDestructuring(arr: ts.ArrayBindingOrAssignmentPattern, pandaGen: PandaGen, compiler: Compiler): void {
     let iter = pandaGen.getTemp();
     let nextMethod = pandaGen.getTemp();
     let iterDone = pandaGen.getTemp();
@@ -134,18 +134,18 @@ function compileArrayDestructuring(arr: ts.ArrayBindingOrAssignmentPattern, pand
         pandaGen.condition(
             element,
             ts.SyntaxKind.ExclamationEqualsEqualsToken,
-            getVregisterCache(pandaGen, CacheList.True),
+            getVregisterCache(pandaGen, CacheList.TRUE),
             hasInit ? getDefaultLabel : getUndefinedLabel
         );
 
-        // iterdone == false, get current itervalue
+        // iterdone === false, get current itervalue
         iterator.iteratorValue(nextResult);
 
         if (hasInit) {
             pandaGen.condition(
                 element,
                 ts.SyntaxKind.ExclamationEqualsEqualsToken,
-                getVregisterCache(pandaGen, CacheList.undefined),
+                getVregisterCache(pandaGen, CacheList.UNDEFINED),
                 getDefaultLabel
             )
 
@@ -161,7 +161,7 @@ function compileArrayDestructuring(arr: ts.ArrayBindingOrAssignmentPattern, pand
         }
 
         pandaGen.label(element, getUndefinedLabel);
-        pandaGen.loadAccumulator(element, getVregisterCache(pandaGen, CacheList.undefined));
+        pandaGen.loadAccumulator(element, getVregisterCache(pandaGen, CacheList.UNDEFINED));
 
         pandaGen.label(element, storeLabel);
         lRef.setValue();
@@ -173,7 +173,7 @@ function compileArrayDestructuring(arr: ts.ArrayBindingOrAssignmentPattern, pand
     pandaGen.condition(
         arr,
         ts.SyntaxKind.EqualsEqualsEqualsToken,
-        getVregisterCache(pandaGen, CacheList.True),
+        getVregisterCache(pandaGen, CacheList.TRUE),
         normalClose
     );
 
@@ -197,7 +197,7 @@ function compileArrayDestructuring(arr: ts.ArrayBindingOrAssignmentPattern, pand
 }
 
 function emitRestElement(restElement: ts.BindingName | ts.Expression, iterator: Iterator, iterResult: VReg,
-                         pandaGen: PandaGen, compiler: Compiler, isDeclaration: boolean) {
+                         pandaGen: PandaGen, compiler: Compiler, isDeclaration: boolean): void {
     let arrayObj = pandaGen.getTemp();
     let index = pandaGen.getTemp();
 
@@ -218,12 +218,12 @@ function emitRestElement(restElement: ts.BindingName | ts.Expression, iterator:
 
     pandaGen.label(restElement, nextLabel);
 
-    // if iterDone == true, done with the process of building array
+    // if iterDone === true, done with the process of building array
     iterator.iteratorComplete(iterResult);
     pandaGen.condition(
         restElement,
         ts.SyntaxKind.ExclamationEqualsEqualsToken,
-        getVregisterCache(pandaGen, CacheList.True),
+        getVregisterCache(pandaGen, CacheList.TRUE),
         doneLabel
     );
 
@@ -247,7 +247,7 @@ function emitRestElement(restElement: ts.BindingName | ts.Expression, iterator:
     pandaGen.freeTemps(arrayObj, index);
 }
 
-function compileObjectDestructuring(obj: ts.ObjectBindingOrAssignmentPattern, pandaGen: PandaGen, compiler: Compiler) {
+function compileObjectDestructuring(obj: ts.ObjectBindingOrAssignmentPattern, pandaGen: PandaGen, compiler: Compiler): void {
     let value = pandaGen.getTemp();
     pandaGen.storeAccumulator(obj, value);
 
@@ -256,16 +256,16 @@ function compileObjectDestructuring(obj: ts.ObjectBindingOrAssignmentPattern, pa
     let elementsLength = elements.length;
 
     // check if value is coercible
-    if (elementsLength == 0 ||
+    if (elementsLength === 0 ||
         (isDeclaration && isRestElement(<ts.BindingElement>elements[0])) ||
         (!isDeclaration && ts.isSpreadAssignment(elements[0]))) {
         let notNullish: Label = new Label();
         let nullLish: Label = new Label();
 
         pandaGen.loadAccumulator(obj, value);
-        pandaGen.condition(obj, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.Null), nullLish);
+        pandaGen.condition(obj, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.NULL), nullLish);
         pandaGen.loadAccumulator(obj, value);
-        pandaGen.condition(obj, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.undefined), nullLish);
+        pandaGen.condition(obj, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.UNDEFINED), nullLish);
         pandaGen.branch(obj, notNullish);
 
         // value == null or undefined, throw error
@@ -367,7 +367,7 @@ function compileObjectDestructuring(obj: ts.ObjectBindingOrAssignmentPattern, pa
             pandaGen.condition(
                 element,
                 ts.SyntaxKind.ExclamationEqualsEqualsToken,
-                getVregisterCache(pandaGen, CacheList.undefined),
+                getVregisterCache(pandaGen, CacheList.UNDEFINED),
                 getDefaultLabel
             );
 
@@ -390,13 +390,13 @@ function compileObjectDestructuring(obj: ts.ObjectBindingOrAssignmentPattern, pa
 }
 
 function emitRestProperty(restProperty: ts.BindingElement | ts.SpreadAssignment, excludedProp: Array<VReg | string>,
-                          obj: VReg, pandaGen: PandaGen, compiler: Compiler) {
+                          obj: VReg, pandaGen: PandaGen, compiler: Compiler): void {
     let isDeclaration = ts.isBindingElement(restProperty) ? true : false;
     let target = isDeclaration ? (<ts.BindingElement>restProperty).name : (<ts.SpreadAssignment>restProperty).expression;
     let lRef = LReference.generateLReference(compiler, target, true);
 
-    if (excludedProp.length == 0) {
-        excludedProp = [getVregisterCache(pandaGen, CacheList.undefined)];
+    if (excludedProp.length === 0) {
+        excludedProp = [getVregisterCache(pandaGen, CacheList.UNDEFINED)];
     }
 
     // Create a Object with the information of excluded properties
@@ -419,7 +419,7 @@ function emitRestProperty(restProperty: ts.BindingElement | ts.SpreadAssignment,
     pandaGen.freeTemps(...namedPropRegs);
 }
 
-function isRestElement(node: ts.BindingElement) {
+function isRestElement(node: ts.BindingElement): boolean {
     if (node.dotDotDotToken) {
         return true;
     }
diff --git a/ts2panda/src/debuginfo.ts b/ts2panda/src/debuginfo.ts
index 7e95232598..0d86a47fc6 100644
--- a/ts2panda/src/debuginfo.ts
+++ b/ts2panda/src/debuginfo.ts
@@ -36,13 +36,13 @@ export class DebugPosInfo {
     private br: number | undefined;  // bound right
     private l: number = -1;  // line number
     private c: number = -1;  // column number
-    private nodeKind: NodeKind | undefined = NodeKind.FirstNodeOfFunction;
+    private nodeKind: NodeKind | undefined = NodeKind.FIRST_NODE_OF_FUNCTION;
 
     constructor() { }
 
     public setDebugPosInfoNodeState(extendedNode: ts.Node | NodeKind): void {
         if (DebugInfo.isNode(extendedNode)) {
-            this.nodeKind = NodeKind.Normal;
+            this.nodeKind = NodeKind.NORMAL;
         } else {
             this.nodeKind = <NodeKind>extendedNode;
         }
@@ -84,7 +84,7 @@ export class DebugPosInfo {
         return this.c;
     }
 
-    public ClearNodeKind(): void {
+    public clearNodeKind(): void {
         this.nodeKind = undefined;
     }
 }
@@ -128,9 +128,9 @@ export class VariableDebugInfo {
 }
 
 export enum NodeKind {
-    Normal,
-    Invalid,
-    FirstNodeOfFunction,
+    NORMAL,
+    INVALID,
+    FIRST_NODE_OF_FUNCTION,
 }
 
 export class DebugInfo {
@@ -138,17 +138,17 @@ export class DebugInfo {
     private static lastNode: ts.Node;
     constructor() { }
 
-    public static isNode(extendedNode: ts.Node | NodeKind) {
-        if (extendedNode != NodeKind.Invalid &&
-            extendedNode != NodeKind.FirstNodeOfFunction &&
-            extendedNode != NodeKind.Normal) {
+    public static isNode(extendedNode: ts.Node | NodeKind): boolean {
+        if (extendedNode != NodeKind.INVALID &&
+            extendedNode != NodeKind.FIRST_NODE_OF_FUNCTION &&
+            extendedNode != NodeKind.NORMAL) {
             return true;
         }
 
         return false;
     }
 
-    public static updateLastNode(lastNode: ts.Node | NodeKind) {
+    public static updateLastNode(lastNode: ts.Node | NodeKind): void {
         if (DebugInfo.isNode(lastNode)) {
             DebugInfo.lastNode = <ts.Node>lastNode;
         }
@@ -181,7 +181,7 @@ export class DebugInfo {
         }
     }
 
-    public static setPosInfoForUninitializeIns(posInfo: DebugPosInfo, pandaGen: PandaGen) {
+    public static setPosInfoForUninitializeIns(posInfo: DebugPosInfo, pandaGen: PandaGen): void {
         let firstStmt = pandaGen.getFirstStmt();
         if (firstStmt) {
             let res = this.searchForPos(firstStmt);
@@ -193,7 +193,7 @@ export class DebugInfo {
         }
     }
 
-    public static setInvalidPosInfoForUninitializeIns(posInfo: DebugPosInfo, pandaGen: PandaGen) {
+    public static setInvalidPosInfoForUninitializeIns(posInfo: DebugPosInfo, pandaGen: PandaGen): void {
         posInfo.setSourecLineNum(-1);
         posInfo.setSourecColumnNum(-1);
     }
@@ -275,13 +275,13 @@ export class DebugInfo {
         return length;
     }
 
-    private static setPosDebugInfo(pandaGen: PandaGen) {
+    private static setPosDebugInfo(pandaGen: PandaGen): void {
         let insns: IRNode[] = pandaGen.getInsns();
         let offset = 0;
 
         // count pos offset
         for (let i = 0; i < insns.length; i++) {
-            if (insns[i].debugPosInfo.getDebugPosInfoNodeState() == NodeKind.FirstNodeOfFunction) {
+            if (insns[i].debugPosInfo.getDebugPosInfoNodeState() === NodeKind.FIRST_NODE_OF_FUNCTION) {
                 DebugInfo.setInvalidPosInfoForUninitializeIns(insns[i].debugPosInfo, pandaGen);
             }
 
@@ -301,7 +301,7 @@ export class DebugInfo {
         }
     }
 
-    private static setVariablesDebugInfo(pandaGen: PandaGen) {
+    private static setVariablesDebugInfo(pandaGen: PandaGen): void {
         let insns = pandaGen.getInsns();
 
         for (let i = 0; i < insns.length; i++) {
@@ -330,7 +330,7 @@ export class DebugInfo {
                 if (!value.hasAlreadyBinded()) {
                     return;
                 }
-                if (value.getName() == "0this" || value.getName() == "0newTarget") {
+                if (value.getName() === "0this" || value.getName() === "0newTarget") {
                     return;
                 }
                 let variableInfo = new VariableDebugInfo(key, "any", "any", (value.getVreg().num));
@@ -341,7 +341,7 @@ export class DebugInfo {
         });
     }
 
-    public static setDebugInfo(pandaGen: PandaGen) {
+    public static setDebugInfo(pandaGen: PandaGen): void {
         // set position debug info
         DebugInfo.setPosDebugInfo(pandaGen);
         if (CmdOptions.isDebugMode()) {
@@ -354,7 +354,7 @@ export class DebugInfo {
         }
     }
 
-    public static setSourceFileDebugInfo(pandaGen: PandaGen, node: ts.SourceFile | ts.FunctionLikeDeclaration) {
+    public static setSourceFileDebugInfo(pandaGen: PandaGen, node: ts.SourceFile | ts.FunctionLikeDeclaration): void {
         let sourceFile = jshelpers.getSourceFileOfNode(node);
         if (CmdOptions.getSourceFile().length > 0) {
             pandaGen.setSourceFileDebugInfo(CmdOptions.getSourceFile());
@@ -367,11 +367,11 @@ export class DebugInfo {
         }
     }
 
-    public static copyDebugInfo(insn: IRNode, expansion: IRNode[]) {
+    public static copyDebugInfo(insn: IRNode, expansion: IRNode[]): void {
         expansion.forEach(irNode => irNode.debugPosInfo = insn.debugPosInfo);
     }
 
-    public static addDebugIns(scope: Scope, pandaGen: PandaGen, isStart: boolean) {
+    public static addDebugIns(scope: Scope, pandaGen: PandaGen, isStart: boolean): void {
         if (!CmdOptions.isDebugMode()) {
             return;
         }
diff --git a/ts2panda/src/ecmaModule.ts b/ts2panda/src/ecmaModule.ts
index d69254de38..4b6ac42705 100644
--- a/ts2panda/src/ecmaModule.ts
+++ b/ts2panda/src/ecmaModule.ts
@@ -70,7 +70,7 @@ export class SourceTextModuleRecord {
     // Targetcase 2: import {x} from 'test.js';
     // Targetcase 3: import {x as y} from 'test.js';
     // Targetcase 4: import defaultExport from 'test.js'
-    addImportEntry(node: ts.Node, importName: string, localName: string, moduleRequest: string) {
+    addImportEntry(node: ts.Node, importName: string, localName: string, moduleRequest: string): void {
         let importEntry: Entry = new Entry(node, undefined, localName, importName, this.addModuleRequest(moduleRequest));
         // We don't care if there's already an entry for this local name, as in that
         // case we will report an error when declaring the variable.
@@ -85,7 +85,7 @@ export class SourceTextModuleRecord {
     }
 
     // Targetcase 1: import * as x from 'test.js';
-    addStarImportEntry(node: ts.Node, localName: string, moduleRequest: string) {
+    addStarImportEntry(node: ts.Node, localName: string, moduleRequest: string): void {
         let starImportEntry: Entry = new Entry(node, undefined, localName, undefined, this.addModuleRequest(moduleRequest));
         this.namespaceImportEntries.push(starImportEntry);
     }
@@ -95,7 +95,7 @@ export class SourceTextModuleRecord {
     // Targetcase 3: export VariableStatement
     // Targetcase 4: export Declaration
     // Targetcase 5: export default ...
-    addLocalExportEntry(node: ts.Node, exportName: string, localName: string) {
+    addLocalExportEntry(node: ts.Node, exportName: string, localName: string): void {
         let localExportEntry: Entry = new Entry(node, exportName, localName, undefined);
         if (this.localExportEntries.has(localName)) {
             this.localExportEntries.get(localName)!.push(localExportEntry);
@@ -107,46 +107,46 @@ export class SourceTextModuleRecord {
     // Targetcase 1: export {x} from 'test.js';
     // Targetcase 2: export {x as y} from 'test.js';
     // Targetcase 3: import { x } from 'test.js'; export { x }
-    addIndirectExportEntry(node: ts.Node, importName: string, exportName: string, moduleRequest: string) {
+    addIndirectExportEntry(node: ts.Node, importName: string, exportName: string, moduleRequest: string): void {
         let indirectExportEntry: Entry = new Entry(node, exportName, undefined, importName, this.addModuleRequest(moduleRequest));
         this.indirectExportEntries.push(indirectExportEntry);
     }
 
     // Targetcase 1: export * from 'test.js';
-    addStarExportEntry(node: ts.Node, moduleRequest: string) {
+    addStarExportEntry(node: ts.Node, moduleRequest: string): void {
         let starExportEntry: Entry = new Entry(node, undefined, undefined, undefined, this.addModuleRequest(moduleRequest));
         this.starExportEntries.push(starExportEntry);
     }
 
-    getModuleName() {
+    getModuleName(): string {
         return this.moduleName;
     }
 
-    getModuleRequests() {
+    getModuleRequests(): string[] {
         return this.moduleRequests;
     }
 
-    getRegularImportEntries() {
+    getRegularImportEntries(): Map<string, Entry> {
         return this.regularImportEntries;
     }
 
-    getNamespaceImportEntries() {
+    getNamespaceImportEntries(): Entry[] {
         return this.namespaceImportEntries;
     }
 
-    getLocalExportEntries() {
+    getLocalExportEntries(): Map<string, Entry[]> {
         return this.localExportEntries;
     }
 
-    getStarExportEntries() {
+    getStarExportEntries(): Entry[] {
         return this.starExportEntries;
     }
 
-    getIndirectExportEntries() {
+    getIndirectExportEntries(): Entry[] {
         return this.indirectExportEntries;
     }
 
-    makeIndirectExportsExplicit() {
+    makeIndirectExportsExplicit(): void {
         // @ts-ignore
         this.localExportEntries.forEach((entries: Array<Entry>, localName: string) => {
             let importEntry: Entry | undefined = this.regularImportEntries.get(localName);
@@ -163,7 +163,7 @@ export class SourceTextModuleRecord {
         });
     }
 
-    nextDuplicateExportEntry(candidate: Entry, exportNameEntry: Map<string, Entry>, currentCandidate: Entry | undefined) {
+    nextDuplicateExportEntry(candidate: Entry, exportNameEntry: Map<string, Entry>, currentCandidate: Entry | undefined): Entry {
         if (!exportNameEntry.has(candidate.exportName!)) {
             exportNameEntry.set(candidate.exportName!, candidate);
             return currentCandidate;
@@ -194,50 +194,54 @@ export class SourceTextModuleRecord {
         return duplicateEntry;
     }
 
-    validateModuleRecordEntries(moduleScope: ModuleScope) {
+    validateModuleRecordEntries(moduleScope: ModuleScope): void {
         // check module is well-formed and report errors if not
         {
             let dupExportEntry: Entry | undefined = this.searchDuplicateExport();
             if (dupExportEntry !== undefined) {
-                throw new DiagnosticError(dupExportEntry.node, DiagnosticCode.Module_0_has_already_exported_a_member_named_1, getSourceFileOfNode(dupExportEntry.node), [getSourceFileOfNode(dupExportEntry.node).fileName, dupExportEntry.exportName]);
+                throw new DiagnosticError(dupExportEntry.node, DiagnosticCode.Module_0_has_already_exported_a_member_named_1,
+                                          getSourceFileOfNode(dupExportEntry.node),
+                                          [getSourceFileOfNode(dupExportEntry.node).fileName, dupExportEntry.exportName]);
             }
         }
 
         this.localExportEntries.forEach((entry: Array<Entry>, localName: string) => {
             if (!moduleScope.hasDecl(localName) && localName != '*default*') {
-                throw new DiagnosticError(entry[0].node, DiagnosticCode.Module_0_has_no_exported_member_1, getSourceFileOfNode(entry[0].node), [getSourceFileOfNode(entry[0].node).fileName, localName]);
+                throw new DiagnosticError(entry[0].node, DiagnosticCode.Module_0_has_no_exported_member_1,
+                                          getSourceFileOfNode(entry[0].node),
+                                          [getSourceFileOfNode(entry[0].node).fileName, localName]);
             }
         });
 
         this.makeIndirectExportsExplicit();
     }
 
-    setExportedDecls(moduleScope: ModuleScope) {
+    setExportedDecls(moduleScope: ModuleScope): void {
         // @ts-ignore
         this.localExportEntries.forEach((entry: Array<Entry>, localName: string) => {
             moduleScope.setExportDecl(localName);
         })
     }
 
-    setModuleEnvironment(moduleScope: ModuleScope) {
+    setModuleEnvironment(moduleScope: ModuleScope): void {
         this.validateModuleRecordEntries(moduleScope);
         this.setExportedDecls(moduleScope);
     }
 }
 
-export function setModuleNamespaceImports(compiler: Compiler, moduleScope: Scope, pandagen: PandaGen) {
+export function setModuleNamespaceImports(compiler: Compiler, moduleScope: Scope, pandagen: PandaGen): void {
     if (!(moduleScope instanceof ModuleScope)) {
         return;
     }
 
     moduleScope.module().getNamespaceImportEntries().forEach(entry => {
-        let namespace_lref = LReference.generateLReference(compiler, (<ts.NamespaceImport>entry.node).name, true);
+        let namespaceLref = LReference.generateLReference(compiler, (<ts.NamespaceImport>entry.node).name, true);
         pandagen.getModuleNamespace(entry.node, entry.moduleRequest);
-        namespace_lref.setValue();
+        namespaceLref.setValue();
     });
 }
 
-export function assignIndexToModuleVariable(moduleScope: Scope) {
+export function assignIndexToModuleVariable(moduleScope: Scope): void {
     if (!(moduleScope instanceof ModuleScope)) {
         return;
     }
diff --git a/ts2panda/src/expression/arrayLiteralExpression.ts b/ts2panda/src/expression/arrayLiteralExpression.ts
index 3ce4a7df27..eff824278d 100644
--- a/ts2panda/src/expression/arrayLiteralExpression.ts
+++ b/ts2panda/src/expression/arrayLiteralExpression.ts
@@ -22,17 +22,17 @@ import { PandaGen } from "../pandagen";
 import { isInteger } from "./numericLiteral";
 import { VReg } from "../irnodes";
 
-export function compileArrayLiteralExpression(compiler: Compiler, node: ts.ArrayLiteralExpression) {
+export function compileArrayLiteralExpression(compiler: Compiler, node: ts.ArrayLiteralExpression): void {
     let pandaGen = compiler.getPandaGen();
     let arrayObj = pandaGen.getTemp();
     createArrayFromElements(node, compiler, node.elements, arrayObj);
     pandaGen.freeTemps(arrayObj);
 }
 
-export function createArrayFromElements(node: ts.Node, compiler: Compiler, elements: ts.NodeArray<ts.Expression>, arrayObj: VReg) {
+export function createArrayFromElements(node: ts.Node, compiler: Compiler, elements: ts.NodeArray<ts.Expression>, arrayObj: VReg): void {
     let pandaGen = compiler.getPandaGen();
     // empty Array
-    if (elements.length == 0) {
+    if (elements.length === 0) {
         pandaGen.createEmptyArray(node);
         pandaGen.storeAccumulator(node, arrayObj);
         return;
@@ -51,7 +51,7 @@ export function createArrayFromElements(node: ts.Node, compiler: Compiler, eleme
 
             if (!arrayCreated) {
                 literalBuffer.addLiterals(elem);
-                if (i == elements.length - 1) {
+                if (i === elements.length - 1) {
                     emitCreateArrayWithBuffer(pandaGen, literalBuffer, element);
                     pandaGen.storeAccumulator(element, arrayObj);
                     arrayCreated = true;
@@ -93,7 +93,7 @@ export function createArrayFromElements(node: ts.Node, compiler: Compiler, eleme
                 arrayCreated = true;
             }
 
-            if (i == elements.length - 1) {
+            if (i === elements.length - 1) {
                 // omittedExpression is the last element, we need to set the length of the array
                 if (hasSpread) {
                     pandaGen.loadAccumulator(element, indexReg);
@@ -158,7 +158,7 @@ function parseConstantExpr(element: ts.Expression): Literal {
     return elem;
 }
 
-function emitCreateArrayWithBuffer(pandaGen: PandaGen, literalBuffer: LiteralBuffer, element: ts.Expression) {
+function emitCreateArrayWithBuffer(pandaGen: PandaGen, literalBuffer: LiteralBuffer, element: ts.Expression): void {
     if (literalBuffer.isEmpty()) {
         pandaGen.createEmptyArray(element);
     } else {
@@ -167,13 +167,13 @@ function emitCreateArrayWithBuffer(pandaGen: PandaGen, literalBuffer: LiteralBuf
     }
 }
 
-function storeElementIfSpreadExisted(pandaGen: PandaGen, element: ts.Expression, arrayObj: VReg, indexReg: VReg) {
+function storeElementIfSpreadExisted(pandaGen: PandaGen, element: ts.Expression, arrayObj: VReg, indexReg: VReg): void {
     pandaGen.storeOwnProperty(element, arrayObj, indexReg);
     pandaGen.unary(element, ts.SyntaxKind.PlusPlusToken, indexReg);
     pandaGen.storeAccumulator(element, indexReg);
 }
 
-function storeSpreadElement(compiler: Compiler, pandaGen: PandaGen, element: ts.SpreadElement, arrayObj: VReg, indexReg: VReg) {
+function storeSpreadElement(compiler: Compiler, pandaGen: PandaGen, element: ts.SpreadElement, arrayObj: VReg, indexReg: VReg): void {
     compiler.compileExpression(element.expression);
     pandaGen.storeArraySpreadElement(element, arrayObj, indexReg);
     pandaGen.storeAccumulator(element, indexReg);
diff --git a/ts2panda/src/expression/bigIntLiteral.ts b/ts2panda/src/expression/bigIntLiteral.ts
index 912769c093..5e4d7d9d04 100644
--- a/ts2panda/src/expression/bigIntLiteral.ts
+++ b/ts2panda/src/expression/bigIntLiteral.ts
@@ -17,7 +17,7 @@ import * as ts from "typescript";
 import * as jshelpers from "../jshelpers";
 import { PandaGen } from "../pandagen";
 
-export function compileBigIntLiteral(pandaGen: PandaGen, lit: ts.BigIntLiteral) {
+export function compileBigIntLiteral(pandaGen: PandaGen, lit: ts.BigIntLiteral): void {
     let text = jshelpers.getTextOfIdentifierOrLiteral(lit);
     text = text.substring(0, text.length-1);
     pandaGen.loadAccumulatorBigInt(lit, text);
diff --git a/ts2panda/src/expression/callExpression.ts b/ts2panda/src/expression/callExpression.ts
index a42cb04296..3ee9eee9b7 100644
--- a/ts2panda/src/expression/callExpression.ts
+++ b/ts2panda/src/expression/callExpression.ts
@@ -24,12 +24,12 @@ import { getObjAndProp } from "./memberAccessExpression";
 
 
 // @ts-ignore
-export function compileCallExpression(expr: ts.CallExpression, compiler: Compiler, inTailPos?: boolean) {
+export function compileCallExpression(expr: ts.CallExpression, compiler: Compiler, inTailPos?: boolean): void {
     let pandaGen = compiler.getPandaGen();
 
     let innerExpression = ts.skipPartiallyEmittedExpressions(expr.expression);
 
-    if (innerExpression.kind == ts.SyntaxKind.ImportKeyword) {
+    if (innerExpression.kind === ts.SyntaxKind.ImportKeyword) {
         compiler.compileExpression(expr.arguments[0]);
         pandaGen.dynamicImportCall(expr);
         return;
@@ -42,7 +42,7 @@ export function compileCallExpression(expr: ts.CallExpression, compiler: Compile
         }
     }
 
-    if (innerExpression.kind == ts.SyntaxKind.SuperKeyword) {
+    if (innerExpression.kind === ts.SyntaxKind.SuperKeyword) {
         let args: VReg[] = [];
         let hasSpread = emitCallArguments(compiler, expr, args);
         compileSuperCall(compiler, expr, args, hasSpread);
@@ -69,7 +69,7 @@ export function getHiddenParameters(expr: ts.Expression, compiler: Compiler) {
         // @ts-ignore
         let { obj: obj, prop: prop } = getObjAndProp(<ts.PropertyAccessExpression | ts.ElementAccessExpression>expr, thisReg, propReg, compiler);
 
-        if ((<ts.PropertyAccessExpression | ts.ElementAccessExpression>expr).expression.kind == ts.SyntaxKind.SuperKeyword) {
+        if ((<ts.PropertyAccessExpression | ts.ElementAccessExpression>expr).expression.kind === ts.SyntaxKind.SuperKeyword) {
             compileSuperProperty(compiler, expr, thisReg, prop);
         } else {
             pandaGen.loadObjProperty(
@@ -90,7 +90,7 @@ export function getHiddenParameters(expr: ts.Expression, compiler: Compiler) {
     return { arguments: args, passThis: passThis };
 }
 
-function emitCallArguments(compiler: Compiler, expr: ts.CallExpression, args: VReg[]) {
+function emitCallArguments(compiler: Compiler, expr: ts.CallExpression, args: VReg[]): boolean {
     let pandaGen = compiler.getPandaGen();
     let hasSpread = false;
     for (let i = 0; i < expr.arguments.length; i++) {
@@ -113,7 +113,7 @@ function emitCallArguments(compiler: Compiler, expr: ts.CallExpression, args: VR
     return hasSpread;
 }
 
-export function emitCall(expr: ts.CallExpression, args: VReg[], passThis: boolean, compiler: Compiler) {
+export function emitCall(expr: ts.CallExpression, args: VReg[], passThis: boolean, compiler: Compiler): void {
     let pandaGen = compiler.getPandaGen();
     let hasSpread = emitCallArguments(compiler, expr, args);
     let callee = expr.expression;
@@ -139,7 +139,7 @@ export function emitCall(expr: ts.CallExpression, args: VReg[], passThis: boolea
 
     // spread argument exist
     let calleeReg = args[0];
-    let thisReg = passThis ? args[1] : getVregisterCache(pandaGen, CacheList.undefined);
+    let thisReg = passThis ? args[1] : getVregisterCache(pandaGen, CacheList.UNDEFINED);
     let argArray = pandaGen.getTemp();
     createArrayFromElements(expr, compiler, <ts.NodeArray<ts.Expression>>expr.arguments, argArray);
     pandaGen.callSpread(debugNode, calleeReg, thisReg, argArray);
diff --git a/ts2panda/src/expression/compileCommaListExpression.ts b/ts2panda/src/expression/compileCommaListExpression.ts
index 4f1ab59b64..5394ff5d47 100644
--- a/ts2panda/src/expression/compileCommaListExpression.ts
+++ b/ts2panda/src/expression/compileCommaListExpression.ts
@@ -17,7 +17,7 @@ import * as ts from "typescript";
 import { Compiler } from "../compiler";
 
 
-export function compileCommaListExpression(compiler: Compiler, exprList: ts.CommaListExpression) {
+export function compileCommaListExpression(compiler: Compiler, exprList: ts.CommaListExpression): void {
     exprList.elements.forEach(expr => {
         compiler.compileExpression(expr);
     })
diff --git a/ts2panda/src/expression/memberAccessExpression.ts b/ts2panda/src/expression/memberAccessExpression.ts
index 1183bb7bef..b5c792eff1 100644
--- a/ts2panda/src/expression/memberAccessExpression.ts
+++ b/ts2panda/src/expression/memberAccessExpression.ts
@@ -21,12 +21,12 @@ import { compileSuperProperty } from "../statement/classStatement";
 
 const MAX_LENGTH = 2 ** 32 - 1;
 
-export function compileMemberAccessExpression(node: ts.ElementAccessExpression | ts.PropertyAccessExpression, compiler: Compiler) {
+export function compileMemberAccessExpression(node: ts.ElementAccessExpression | ts.PropertyAccessExpression, compiler: Compiler): void {
     let pandaGen = compiler.getPandaGen();
     let objReg = pandaGen.getTemp();
     let propReg = pandaGen.getTemp();
 
-    let { obj: obj, prop: property } = getObjAndProp(node, objReg, propReg, compiler)
+    let { obj: obj, prop: property } = getObjAndProp(node, objReg, propReg, compiler);
 
     if (jshelpers.isSuperProperty(node)) {
         // make sure "this" is stored in lexical env if needed
@@ -44,7 +44,8 @@ export function compileMemberAccessExpression(node: ts.ElementAccessExpression |
     pandaGen.freeTemps(objReg, propReg);
 }
 
-export function getObjAndProp(node: ts.ElementAccessExpression | ts.PropertyAccessExpression, objReg: VReg, propReg: VReg, compiler: Compiler) {
+export function getObjAndProp(node: ts.ElementAccessExpression | ts.PropertyAccessExpression,
+                              objReg: VReg, propReg: VReg, compiler: Compiler): { obj: VReg; prop: any; } {
     let pandaGen = compiler.getPandaGen();
     let obj = objReg;
     let prop: VReg | string | number = propReg;
@@ -66,7 +67,7 @@ export function getObjAndProp(node: ts.ElementAccessExpression | ts.PropertyAcce
             prop = jshelpers.getTextOfIdentifierOrLiteral(node.argumentExpression);
             // deal with case like a["1"]
             let temp = Number(prop);
-            if (!isNaN(Number.parseFloat(prop)) && !isNaN(temp) && isValidIndex(temp) && String(temp) == prop) {
+            if (!isNaN(Number.parseFloat(prop)) && !isNaN(temp) && isValidIndex(temp) && String(temp) === prop) {
                 prop = temp;
             }
         } else if (ts.isNumericLiteral(node.argumentExpression)) {
@@ -75,10 +76,10 @@ export function getObjAndProp(node: ts.ElementAccessExpression | ts.PropertyAcce
                 prop = prop.toString();
             }
         } else if (ts.isPrefixUnaryExpression(node.argumentExpression) && ts.isNumericLiteral(node.argumentExpression.operand) &&
-            (node.argumentExpression.operator == ts.SyntaxKind.MinusToken || node.argumentExpression.operator == ts.SyntaxKind.PlusToken)) {
+            (node.argumentExpression.operator === ts.SyntaxKind.MinusToken || node.argumentExpression.operator === ts.SyntaxKind.PlusToken)) {
             let expr = node.argumentExpression;
             let temp = parseFloat(jshelpers.getTextOfIdentifierOrLiteral(expr.operand));
-            if (expr.operator == ts.SyntaxKind.MinusToken) {
+            if (expr.operator === ts.SyntaxKind.MinusToken) {
                 prop = temp === 0 ? temp : "-" + temp.toString();
             } else {
                 if (!isValidIndex(temp)) {
@@ -97,7 +98,7 @@ export function getObjAndProp(node: ts.ElementAccessExpression | ts.PropertyAcce
     return { obj: obj, prop: prop };
 }
 
-export function isValidIndex(num: number) {
+export function isValidIndex(num: number): boolean {
     if ((num >= 0) && (num < MAX_LENGTH) && (Number.isInteger(num))) {
         return true;
     }
diff --git a/ts2panda/src/expression/metaProperty.ts b/ts2panda/src/expression/metaProperty.ts
index f9c7447409..aa4fbb9a70 100644
--- a/ts2panda/src/expression/metaProperty.ts
+++ b/ts2panda/src/expression/metaProperty.ts
@@ -18,10 +18,10 @@ import * as ts from "typescript";
 import { Compiler } from "../compiler";
 import * as jshelpers from "../jshelpers";
 
-export function compileMetaProperty(expr: ts.MetaProperty, compiler: Compiler) {
+export function compileMetaProperty(expr: ts.MetaProperty, compiler: Compiler): void {
     let curScope = compiler.getCurrentScope();
     let id = jshelpers.getTextOfIdentifierOrLiteral(expr.name);
-    if (id == "target") {
+    if (id === "target") {
         let { scope, level, v } = curScope.find(MandatoryNewTarget);
 
         if (!v) {
diff --git a/ts2panda/src/expression/newExpression.ts b/ts2panda/src/expression/newExpression.ts
index 4f05d929db..68fc2f5f2e 100644
--- a/ts2panda/src/expression/newExpression.ts
+++ b/ts2panda/src/expression/newExpression.ts
@@ -19,7 +19,7 @@ import { VReg } from "../irnodes";
 import { containSpreadElement } from "../base/util";
 import { createArrayFromElements } from "./arrayLiteralExpression";
 
-export function compileNewExpression(expr: ts.NewExpression, compiler: Compiler) {
+export function compileNewExpression(expr: ts.NewExpression, compiler: Compiler): void {
     let pandaGen = compiler.getPandaGen();
     let ctorReg = pandaGen.getTemp();
 
diff --git a/ts2panda/src/expression/numericLiteral.ts b/ts2panda/src/expression/numericLiteral.ts
index b20056c5d2..d2607c9082 100644
--- a/ts2panda/src/expression/numericLiteral.ts
+++ b/ts2panda/src/expression/numericLiteral.ts
@@ -35,15 +35,15 @@ export function isInteger(value: number): Boolean {
     return true;
 }
 
-export function compileNumericLiteral(pandaGen: PandaGen, lit: ts.NumericLiteral) {
+export function compileNumericLiteral(pandaGen: PandaGen, lit: ts.NumericLiteral): void {
     let text = jshelpers.getTextOfIdentifierOrLiteral(lit);
     let value = Number.parseFloat(text);
     // check whether value is a NaN
     if (Number.isNaN(value)) {
-        pandaGen.loadAccumulator(lit, getVregisterCache(pandaGen, CacheList.NaN));
+        pandaGen.loadAccumulator(lit, getVregisterCache(pandaGen, CacheList.NAN));
     } else if (!Number.isFinite(value)) {
         // check whether value is a Infinity
-        pandaGen.loadAccumulator(lit, getVregisterCache(pandaGen, CacheList.Infinity));
+        pandaGen.loadAccumulator(lit, getVregisterCache(pandaGen, CacheList.INFINITY));
     } else if (isInteger(value)) {
         // check whether value is a SafeInteger
         pandaGen.loadAccumulatorInt(lit, value);
diff --git a/ts2panda/src/expression/objectLiteralExpression.ts b/ts2panda/src/expression/objectLiteralExpression.ts
index 1d6af9384c..e971ed2016 100644
--- a/ts2panda/src/expression/objectLiteralExpression.ts
+++ b/ts2panda/src/expression/objectLiteralExpression.ts
@@ -25,7 +25,7 @@ import { VReg } from "../irnodes";
 import { PropertyKind, Property, generatePropertyFromExpr } from "../base/properties";
 import { LiteralTag, Literal, LiteralBuffer } from "../base/literal";
 
-export function compileObjectLiteralExpression(compiler: Compiler, expr: ts.ObjectLiteralExpression) {
+export function compileObjectLiteralExpression(compiler: Compiler, expr: ts.ObjectLiteralExpression): void {
     let pandaGen = compiler.getPandaGen();
 
     // traverse the properties entries and store the useful information
@@ -35,7 +35,7 @@ export function compileObjectLiteralExpression(compiler: Compiler, expr: ts.Obje
     let hasMethod: boolean = false;
 
     // empty ObjectLiteral expression
-    if (properties.length == 0) {
+    if (properties.length === 0) {
         pandaGen.createEmptyObject(expr);
         pandaGen.storeAccumulator(expr, objReg);
         pandaGen.freeTemps(objReg);
@@ -59,24 +59,24 @@ function compileProperties(compiler: Compiler, properties: Property[], literalBu
     let hasMethod: boolean = false;
 
     for (let prop of properties) {
-        if (prop.getKind() == PropertyKind.Spread || prop.getKind() == PropertyKind.Computed) {
+        if (prop.getKind() === PropertyKind.SPREAD || prop.getKind() === PropertyKind.COMPUTED) {
             break;
         }
 
-        if (prop.getKind() == PropertyKind.Prototype || prop.isRedeclared()) {
+        if (prop.getKind() === PropertyKind.PROTOTYPE || prop.isRedeclared()) {
             continue;
         }
 
         let nameLiteral = new Literal(LiteralTag.STRING, String(prop.getName()));
 
-        if (prop.getKind() == PropertyKind.Constant) {
+        if (prop.getKind() === PropertyKind.CONSTANT) {
             let valLiteral: Literal = createConstantLiteral(prop);
 
             literalBuffer.addLiterals(nameLiteral, valLiteral!);
             prop.setCompiled();  // need to be careful
         }
 
-        if (prop.getKind() == PropertyKind.Variable) {
+        if (prop.getKind() === PropertyKind.VARIABLE) {
             let compilerDriver = compiler.getCompilerDriver();
             let valueNode = prop.getValue();
             let valLiteral: Literal;
@@ -98,7 +98,7 @@ function compileProperties(compiler: Compiler, properties: Property[], literalBu
             }
         }
 
-        if (prop.getKind() == PropertyKind.Accessor) {
+        if (prop.getKind() === PropertyKind.ACCESSOR) {
             let valLiteral = new Literal(LiteralTag.ACCESSOR, null);
             literalBuffer.addLiterals(nameLiteral, valLiteral);
         }
@@ -108,7 +108,7 @@ function compileProperties(compiler: Compiler, properties: Property[], literalBu
 }
 
 function createObject(expr: ts.ObjectLiteralExpression, pandaGen: PandaGen, objReg: VReg,
-                      literalBuffer: LiteralBuffer, hasMethod: boolean, compiler: Compiler) {
+                      literalBuffer: LiteralBuffer, hasMethod: boolean, compiler: Compiler): void {
     if (literalBuffer.isEmpty()) {
         pandaGen.createEmptyObject(expr);
     } else {
@@ -120,22 +120,22 @@ function createObject(expr: ts.ObjectLiteralExpression, pandaGen: PandaGen, objR
 
 function createConstantLiteral(prop: Property): Literal {
     let valLiteral: Literal;
-    if (prop.getValue().kind == ts.SyntaxKind.StringLiteral) {
+    if (prop.getValue().kind === ts.SyntaxKind.StringLiteral) {
         valLiteral = new Literal(LiteralTag.STRING, jshelpers.getTextOfIdentifierOrLiteral(prop.getValue()));
-    } else if (prop.getValue().kind == ts.SyntaxKind.NumericLiteral) {
+    } else if (prop.getValue().kind === ts.SyntaxKind.NumericLiteral) {
         let value = Number.parseFloat(jshelpers.getTextOfIdentifierOrLiteral(prop.getValue()));
         if (isInteger(value)) {
             valLiteral = new Literal(LiteralTag.INTEGER, value);
         } else {
             valLiteral = new Literal(LiteralTag.DOUBLE, value);
         }
-    } else if (prop.getValue().kind == ts.SyntaxKind.TrueKeyword || prop.getValue().kind == ts.SyntaxKind.FalseKeyword) {
-        if (prop.getValue().kind == ts.SyntaxKind.TrueKeyword) {
+    } else if (prop.getValue().kind === ts.SyntaxKind.TrueKeyword || prop.getValue().kind === ts.SyntaxKind.FalseKeyword) {
+        if (prop.getValue().kind === ts.SyntaxKind.TrueKeyword) {
             valLiteral = new Literal(LiteralTag.BOOLEAN, true);
         } else {
             valLiteral = new Literal(LiteralTag.BOOLEAN, false);
         }
-    } else if (prop.getValue().kind == ts.SyntaxKind.NullKeyword) {
+    } else if (prop.getValue().kind === ts.SyntaxKind.NullKeyword) {
         valLiteral = new Literal(LiteralTag.NULLVALUE, null);
     } else {
         throw new Error("Unreachable Kind of Literal");
@@ -144,7 +144,7 @@ function createConstantLiteral(prop: Property): Literal {
     return valLiteral;
 }
 
-function compileAccessorProperty(pandaGen: PandaGen, compiler: Compiler, objReg: VReg, prop: Property) {
+function compileAccessorProperty(pandaGen: PandaGen, compiler: Compiler, objReg: VReg, prop: Property): void {
     let getterReg = pandaGen.getTemp();
     let setterReg = pandaGen.getTemp();
     let propReg = pandaGen.getTemp();
@@ -170,15 +170,15 @@ function compileAccessorProperty(pandaGen: PandaGen, compiler: Compiler, objReg:
     if (prop.getGetter() !== undefined && prop.getSetter() !== undefined) {
         pandaGen.defineGetterSetterByValue(accessor!, objReg, propReg, getterReg, setterReg, false);
     } else if (ts.isGetAccessorDeclaration(accessor!)) {
-        pandaGen.defineGetterSetterByValue(accessor, objReg, propReg, getterReg, getVregisterCache(pandaGen, CacheList.undefined), false);
+        pandaGen.defineGetterSetterByValue(accessor, objReg, propReg, getterReg, getVregisterCache(pandaGen, CacheList.UNDEFINED), false);
     } else {
-        pandaGen.defineGetterSetterByValue(accessor!, objReg, propReg, getVregisterCache(pandaGen, CacheList.undefined), setterReg, false);
+        pandaGen.defineGetterSetterByValue(accessor!, objReg, propReg, getVregisterCache(pandaGen, CacheList.UNDEFINED), setterReg, false);
     }
 
     pandaGen.freeTemps(getterReg, setterReg, propReg);
 }
 
-function compileSpreadProperty(compiler: Compiler, prop: Property, objReg: VReg) {
+function compileSpreadProperty(compiler: Compiler, prop: Property, objReg: VReg): void {
     let pandaGen = compiler.getPandaGen();
 
     compiler.compileExpression(<ts.Expression>prop.getValue());
@@ -186,7 +186,7 @@ function compileSpreadProperty(compiler: Compiler, prop: Property, objReg: VReg)
     pandaGen.copyDataProperties(<ts.Expression>prop.getValue().parent, objReg);
 }
 
-function compileComputedProperty(compiler: Compiler, prop: Property, objReg: VReg) {
+function compileComputedProperty(compiler: Compiler, prop: Property, objReg: VReg): void {
     // Computed can't know its key in compile time, create Object now.
     let pandaGen = compiler.getPandaGen();
 
@@ -211,7 +211,7 @@ function compileComputedProperty(compiler: Compiler, prop: Property, objReg: VRe
             let getter = <ts.GetAccessorDeclaration>prop.getValue();
             createMethodOrAccessor(pandaGen, compiler, objReg, getter);
             pandaGen.storeAccumulator(getter, accessorReg);
-            pandaGen.defineGetterSetterByValue(getter, objReg, keyReg, accessorReg, getVregisterCache(pandaGen, CacheList.undefined), true);
+            pandaGen.defineGetterSetterByValue(getter, objReg, keyReg, accessorReg, getVregisterCache(pandaGen, CacheList.UNDEFINED), true);
             pandaGen.freeTemps(accessorReg);
             break;
         }
@@ -220,7 +220,7 @@ function compileComputedProperty(compiler: Compiler, prop: Property, objReg: VRe
             let setter = <ts.SetAccessorDeclaration>prop.getValue();
             createMethodOrAccessor(pandaGen, compiler, objReg, setter);
             pandaGen.storeAccumulator(setter, accessorReg);
-            pandaGen.defineGetterSetterByValue(setter, objReg, keyReg, getVregisterCache(pandaGen, CacheList.undefined), accessorReg, true);
+            pandaGen.defineGetterSetterByValue(setter, objReg, keyReg, getVregisterCache(pandaGen, CacheList.UNDEFINED), accessorReg, true);
             pandaGen.freeTemps(accessorReg);
             break;
         }
@@ -230,7 +230,7 @@ function compileComputedProperty(compiler: Compiler, prop: Property, objReg: VRe
     pandaGen.freeTemps(keyReg);
 }
 
-function compileProtoProperty(compiler: Compiler, prop: Property, objReg: VReg) {
+function compileProtoProperty(compiler: Compiler, prop: Property, objReg: VReg): void {
     let pandaGen = compiler.getPandaGen();
     let protoReg = pandaGen.getTemp();
 
@@ -240,36 +240,36 @@ function compileProtoProperty(compiler: Compiler, prop: Property, objReg: VReg)
     pandaGen.freeTemps(protoReg);
 }
 
-function setUncompiledProperties(compiler: Compiler, pandaGen: PandaGen, properties: Property[], objReg: VReg) {
+function setUncompiledProperties(compiler: Compiler, pandaGen: PandaGen, properties: Property[], objReg: VReg): void {
     for (let prop of properties) {
         if (!prop.isCompiled()) {
             switch (prop.getKind()) {
-                case PropertyKind.Accessor: {
+                case PropertyKind.ACCESSOR: {
                     compileAccessorProperty(pandaGen, compiler, objReg, prop);
                     break;
                 }
-                case PropertyKind.Spread: {
+                case PropertyKind.SPREAD: {
                     compileSpreadProperty(compiler, prop, objReg);
                     break;
                 }
-                case PropertyKind.Computed: {
+                case PropertyKind.COMPUTED: {
                     compileComputedProperty(compiler, prop, objReg);
                     break;
                 }
-                case PropertyKind.Constant:
-                case PropertyKind.Variable: {
+                case PropertyKind.CONSTANT:
+                case PropertyKind.VARIABLE: {
                     let nameSetting: boolean = false;
                     if (ts.isMethodDeclaration(prop.getValue())) {
                         createMethodOrAccessor(pandaGen, compiler, objReg, <ts.MethodDeclaration>prop.getValue());
                     } else {
                         compiler.compileExpression(<ts.Expression | ts.Identifier>prop.getValue());
-                        nameSetting = needSettingName(<ts.Expression | ts.Identifier>prop.getValue())
-                            && (<string | number>(prop.getName())).toString().lastIndexOf('.') != -1;
+                        nameSetting = needSettingName(<ts.Expression | ts.Identifier>prop.getValue()) &&
+                                      (<string | number>(prop.getName())).toString().lastIndexOf('.') != -1;
                     }
                     pandaGen.storeOwnProperty(prop.getValue().parent, objReg, <string | number>(prop.getName()), nameSetting);
                     break;
                 }
-                case PropertyKind.Prototype: {
+                case PropertyKind.PROTOTYPE: {
                     compileProtoProperty(compiler, prop, objReg);
                     break;
                 }
diff --git a/ts2panda/src/expression/parenthesizedExpression.ts b/ts2panda/src/expression/parenthesizedExpression.ts
index 89d30dccc6..89a7dafd79 100644
--- a/ts2panda/src/expression/parenthesizedExpression.ts
+++ b/ts2panda/src/expression/parenthesizedExpression.ts
@@ -16,7 +16,7 @@
 import * as ts from "typescript";
 
 export function findInnerExprOfParenthesis(expr: ts.ParenthesizedExpression): ts.Expression {
-    while (expr.expression.kind == ts.SyntaxKind.ParenthesizedExpression) {
+    while (expr.expression.kind === ts.SyntaxKind.ParenthesizedExpression) {
         expr = <ts.ParenthesizedExpression>expr.expression;
     }
     return expr.expression;
@@ -24,7 +24,7 @@ export function findInnerExprOfParenthesis(expr: ts.ParenthesizedExpression): ts
 
 export function findOuterNodeOfParenthesis(expr: ts.Node): ts.Node {
     let parent = expr.parent;
-    while (parent.kind == ts.SyntaxKind.ParenthesizedExpression) {
+    while (parent.kind === ts.SyntaxKind.ParenthesizedExpression) {
         parent = parent.parent;
     }
     return parent;
diff --git a/ts2panda/src/expression/regularExpression.ts b/ts2panda/src/expression/regularExpression.ts
index bb7d2e649b..58446c931f 100644
--- a/ts2panda/src/expression/regularExpression.ts
+++ b/ts2panda/src/expression/regularExpression.ts
@@ -31,16 +31,16 @@ export enum RegExpFlags {
 }
 
 
-export function compileRegularExpressionLiteral(compiler: Compiler, regexp: ts.RegularExpressionLiteral) {
+export function compileRegularExpressionLiteral(compiler: Compiler, regexp: ts.RegularExpressionLiteral): void {
     let pandaGen = compiler.getPandaGen();
     let regexpText = regexp.text;
     let regexpPattern = regexpText;
     let regexpFlags = "";
     let firstSlashPos = regexpText.indexOf('/');
     let lastSlashPos = regexpText.lastIndexOf('/');
-    if (firstSlashPos == -1 ||
-        lastSlashPos == -1 ||
-        firstSlashPos == lastSlashPos) {
+    if (firstSlashPos === -1 ||
+        lastSlashPos === -1 ||
+        firstSlashPos === lastSlashPos) {
         throw new DiagnosticError(regexp, DiagnosticCode.Incorrect_regular_expression);
     }
     regexpPattern = regexpText.substring(firstSlashPos + 1, lastSlashPos);
@@ -50,7 +50,7 @@ export function compileRegularExpressionLiteral(compiler: Compiler, regexp: ts.R
 
 }
 
-function updateExpressionFlags(regexpFlags: string, regexp: ts.RegularExpressionLiteral) {
+function updateExpressionFlags(regexpFlags: string, regexp: ts.RegularExpressionLiteral): number {
     let flagsBits: number = 0;
     let flagsBitsTemp: number = 0;
     for (let idx = 0; idx < regexpFlags.length; idx++) {
diff --git a/ts2panda/src/expression/stringLiteral.ts b/ts2panda/src/expression/stringLiteral.ts
index 415300db1b..4bcd10d5b7 100644
--- a/ts2panda/src/expression/stringLiteral.ts
+++ b/ts2panda/src/expression/stringLiteral.ts
@@ -17,7 +17,7 @@ import * as ts from "typescript";
 import * as jshelpers from "../jshelpers";
 import { PandaGen } from "../pandagen";
 
-export function compileStringLiteral(pandaGen: PandaGen, lit: ts.StringLiteral) {
+export function compileStringLiteral(pandaGen: PandaGen, lit: ts.StringLiteral): void {
     let text = jshelpers.getTextOfIdentifierOrLiteral(lit);
     pandaGen.loadAccumulatorString(lit, text);
 }
diff --git a/ts2panda/src/expression/templateExpression.ts b/ts2panda/src/expression/templateExpression.ts
index a6315cb724..401cbf1eaf 100644
--- a/ts2panda/src/expression/templateExpression.ts
+++ b/ts2panda/src/expression/templateExpression.ts
@@ -17,8 +17,8 @@ import * as ts from "typescript";
 import { PandaGen } from "../pandagen";
 import { VReg } from "../irnodes";
 
-function genRawString(pandaGen: PandaGen, expr: ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral) {
-    let text = ""
+function genRawString(pandaGen: PandaGen, expr: ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral): void {
+    let text = "";
     if (ts.isTemplateExpression(expr)) {
         text = expr.head.rawText!;
     } else {
@@ -29,8 +29,8 @@ function genRawString(pandaGen: PandaGen, expr: ts.TemplateExpression | ts.NoSub
     pandaGen.loadAccumulatorString(expr, text);
 }
 
-function genCookedString(pandaGen: PandaGen, expr: ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral) {
-    let text = ""
+function genCookedString(pandaGen: PandaGen, expr: ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral): void {
+    let text = "";
     if (ts.isTemplateExpression(expr)) {
         text = expr.head.text;
     } else {
@@ -45,7 +45,7 @@ function genCookedString(pandaGen: PandaGen, expr: ts.TemplateExpression | ts.No
     pandaGen.loadAccumulatorString(expr, text);
 }
 
-function genTemplateArrayArg(pandaGen: PandaGen, expr: ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral, rawArr: VReg, cookedArr: VReg) {
+function genTemplateArrayArg(pandaGen: PandaGen, expr: ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral, rawArr: VReg, cookedArr: VReg): void {
     let spans = undefined;
     if (ts.isTemplateExpression(expr)) {
         spans = expr.templateSpans;
@@ -63,10 +63,10 @@ function genTemplateArrayArg(pandaGen: PandaGen, expr: ts.TemplateExpression | t
     pandaGen.loadAccumulatorInt(expr, elemIndex);
     pandaGen.storeAccumulator(expr, indexReg);
 
-    genRawString(pandaGen, expr)
+    genRawString(pandaGen, expr);
     pandaGen.storeObjProperty(expr, rawArrTmp, indexReg);
 
-    genCookedString(pandaGen, expr)
+    genCookedString(pandaGen, expr);
     pandaGen.storeObjProperty(expr, cookedArrTmp, indexReg);
     ++elemIndex;
 
@@ -88,7 +88,7 @@ function genTemplateArrayArg(pandaGen: PandaGen, expr: ts.TemplateExpression | t
     pandaGen.freeTemps(indexReg, rawArrTmp, cookedArrTmp);
 }
 
-export function getTemplateObject(pandaGen: PandaGen, expr: ts.TaggedTemplateExpression) {
+export function getTemplateObject(pandaGen: PandaGen, expr: ts.TaggedTemplateExpression): void {
     let templateArgs = pandaGen.getTemp();
     let indexReg = pandaGen.getTemp();
     let rawArr = pandaGen.getTemp();
diff --git a/ts2panda/src/expression/yieldExpression.ts b/ts2panda/src/expression/yieldExpression.ts
index 4280d68c28..0780981b10 100644
--- a/ts2panda/src/expression/yieldExpression.ts
+++ b/ts2panda/src/expression/yieldExpression.ts
@@ -20,7 +20,7 @@ import { CacheList, getVregisterCache } from "../base/vregisterCache";
 import { AsyncGeneratorFunctionBuilder } from "../function/asyncGeneratorFunctionBuilder";
 import { Compiler } from "../compiler";
 
-export function compileYieldExpression(compiler: Compiler, expr: ts.YieldExpression) {
+export function compileYieldExpression(compiler: Compiler, expr: ts.YieldExpression): void {
     if (!(compiler.getFuncBuilder() instanceof GeneratorFunctionBuilder || compiler.getFuncBuilder() instanceof AsyncGeneratorFunctionBuilder)) {
         throw new DiagnosticError(expr.parent, DiagnosticCode.A_yield_expression_is_only_allowed_in_a_generator_body);
     }
@@ -28,19 +28,19 @@ export function compileYieldExpression(compiler: Compiler, expr: ts.YieldExpress
     expr.asteriskToken ? genYieldStarExpr(compiler, expr) : genYieldExpr(compiler, expr);
 }
 
-function genYieldExpr(compiler: Compiler, expr: ts.YieldExpression) {
+function genYieldExpr(compiler: Compiler, expr: ts.YieldExpression): void {
     let pandaGen = compiler.getPandaGen();
     let funcBuilder = <GeneratorFunctionBuilder | AsyncGeneratorFunctionBuilder> compiler.getFuncBuilder();
     if (expr.expression) {
         compiler.compileExpression(expr.expression);
         funcBuilder.yield(expr);
     } else {
-        pandaGen.loadAccumulator(expr, getVregisterCache(pandaGen, CacheList.undefined));
+        pandaGen.loadAccumulator(expr, getVregisterCache(pandaGen, CacheList.UNDEFINED));
         funcBuilder.yield(expr);
     }
 }
 
-function genYieldStarExpr(compiler: Compiler, expr: ts.YieldExpression) {
+function genYieldStarExpr(compiler: Compiler, expr: ts.YieldExpression): void {
     let funcBuilder = <GeneratorFunctionBuilder>compiler.getFuncBuilder();
     if (!expr.expression) {
         throw new Error("yield* must have an expression!");
diff --git a/ts2panda/src/function/asyncFunctionBuilder.ts b/ts2panda/src/function/asyncFunctionBuilder.ts
index 3dc968aff0..ace1776a17 100644
--- a/ts2panda/src/function/asyncFunctionBuilder.ts
+++ b/ts2panda/src/function/asyncFunctionBuilder.ts
@@ -25,9 +25,9 @@ import { CatchTable, LabelPair } from "../statement/tryStatement";
 import { FunctionBuilder, FunctionBuilderType } from "./functionBuilder";
 
 enum ResumeMode {
-    Return,
-    Throw,
-    Next
+    RETURN,
+    THROW,
+    NEXT
 };
 
 /**
@@ -47,8 +47,8 @@ export class AsyncFunctionBuilder extends FunctionBuilder {
     prepare(node: ts.Node): void {
         let pandaGen = this.pg;
 
-        pandaGen.asyncFunctionEnter(NodeKind.Invalid);
-        pandaGen.storeAccumulator(NodeKind.Invalid, this.funcObj);
+        pandaGen.asyncFunctionEnter(NodeKind.INVALID);
+        pandaGen.storeAccumulator(NodeKind.INVALID, this.funcObj);
 
         pandaGen.label(node, this.beginLabel);
     }
@@ -66,12 +66,12 @@ export class AsyncFunctionBuilder extends FunctionBuilder {
     }
 
     implicitReturn(node: ts.Node | NodeKind): void {
-        this.pg.loadAccumulator(node, getVregisterCache(this.pg, CacheList.undefined));
+        this.pg.loadAccumulator(node, getVregisterCache(this.pg, CacheList.UNDEFINED));
         this.pg.asyncFunctionResolve(node, this.funcObj);
         this.pg.return(node);
     }
 
-    private handleMode(node: ts.Node) {
+    private handleMode(node: ts.Node): void {
         let pandaGen = this.pg;
         let modeType = pandaGen.getTemp();
 
@@ -79,7 +79,7 @@ export class AsyncFunctionBuilder extends FunctionBuilder {
         pandaGen.storeAccumulator(node, modeType);
 
         // .reject
-        pandaGen.loadAccumulatorInt(node, ResumeMode.Throw);
+        pandaGen.loadAccumulatorInt(node, ResumeMode.THROW);
 
         let notThrowLabel = new Label();
 
@@ -95,7 +95,7 @@ export class AsyncFunctionBuilder extends FunctionBuilder {
         pandaGen.loadAccumulator(node, this.resumeVal);
     }
 
-    resolve(node: ts.Node | NodeKind, value: VReg) {
+    resolve(node: ts.Node | NodeKind, value: VReg): void {
         let pandaGen = this.pg;
         pandaGen.loadAccumulator(node, value);
         pandaGen.asyncFunctionResolve(node, this.funcObj);
@@ -107,8 +107,8 @@ export class AsyncFunctionBuilder extends FunctionBuilder {
         pandaGen.label(node, this.endLabel);
 
         // exception is in acc
-        pandaGen.asyncFunctionReject(NodeKind.Invalid, this.funcObj);
-        pandaGen.return(NodeKind.Invalid);
+        pandaGen.asyncFunctionReject(NodeKind.INVALID, this.funcObj);
+        pandaGen.return(NodeKind.INVALID);
 
         pandaGen.freeTemps(this.funcObj, this.resumeVal);
 
diff --git a/ts2panda/src/function/asyncGeneratorFunctionBuilder.ts b/ts2panda/src/function/asyncGeneratorFunctionBuilder.ts
index 4484fb628c..47082d9093 100644
--- a/ts2panda/src/function/asyncGeneratorFunctionBuilder.ts
+++ b/ts2panda/src/function/asyncGeneratorFunctionBuilder.ts
@@ -55,7 +55,7 @@ export class AsyncGeneratorFunctionBuilder extends FunctionBuilder {
         this.compiler = compiler;
     }
 
-    prepare(node: ts.Node) {
+    prepare(node: ts.Node): void {
         let pg = this.pg;
 
         // backend handle funcobj, frontend set undefined
@@ -63,7 +63,7 @@ export class AsyncGeneratorFunctionBuilder extends FunctionBuilder {
         pg.storeAccumulator(node, this.funcObj);
 
         pg.label(node, this.beginLabel);
-        pg.loadAccumulator(node, getVregisterCache(pg, CacheList.undefined));
+        pg.loadAccumulator(node, getVregisterCache(pg, CacheList.UNDEFINED));
         pg.suspendGenerator(node, this.funcObj);
         pg.resumeGenerator(node, this.funcObj);
         pg.storeAccumulator(node, this.resumeVal);
@@ -79,7 +79,7 @@ export class AsyncGeneratorFunctionBuilder extends FunctionBuilder {
         let pg = this.pg;
         pg.storeAccumulator(node, this.resumeVal);
         pg.generatorComplete(node, this.funcObj);
-        pg.asyncgeneratorresolve(node, this.funcObj, this.resumeVal, getVregisterCache(pg, CacheList.True));
+        pg.asyncgeneratorresolve(node, this.funcObj, this.resumeVal, getVregisterCache(pg, CacheList.TRUE));
         pg.return(node);
     }
 
@@ -91,16 +91,16 @@ export class AsyncGeneratorFunctionBuilder extends FunctionBuilder {
             this.resumeGenerator(node);
         }
         pg.generatorComplete(node, this.funcObj);
-        pg.asyncgeneratorresolve(node, this.funcObj, this.resumeVal, getVregisterCache(pg, CacheList.True));
+        pg.asyncgeneratorresolve(node, this.funcObj, this.resumeVal, getVregisterCache(pg, CacheList.TRUE));
         pg.return(node);
     }
 
     implicitReturn(node: ts.Node | NodeKind): void {
-        this.pg.loadAccumulator(node, getVregisterCache(this.pg, CacheList.undefined));
+        this.pg.loadAccumulator(node, getVregisterCache(this.pg, CacheList.UNDEFINED));
         this.directReturn(node);
     }
 	
-    yield(node: ts.Node) {
+    yield(node: ts.Node): void {
         let pg = this.pg;
 
         // 27.6.3.8.5 Set value to ? Await(value).
@@ -114,13 +114,13 @@ export class AsyncGeneratorFunctionBuilder extends FunctionBuilder {
          *  is at the top of the execution context stack as the running execution context.
          *  27.6.3.8.9 Return ! AsyncGeneratorResolve(generator, value, false).
          */
-        pg.asyncgeneratorresolve(node, this.funcObj, this.resumeVal, getVregisterCache(pg, CacheList.False));
+        pg.asyncgeneratorresolve(node, this.funcObj, this.resumeVal, getVregisterCache(pg, CacheList.FALSE));
         this.resumeGenerator(node);
 
         this.handleAsyncYieldResume(node);
     }
 
-    yieldStar(node: ts.Node) {
+    yieldStar(node: ts.Node): void {
         let pg = this.pg;
         let method = pg.getTemp();
         let iterator = pg.getTemp();
@@ -139,7 +139,7 @@ export class AsyncGeneratorFunctionBuilder extends FunctionBuilder {
         this.resumeVal = nextResult;
 
         // 6. Let received be NormalCompletion(undefined)
-        pg.storeConst(node, this.resumeVal, CacheList.undefined);
+        pg.storeConst(node, this.resumeVal, CacheList.UNDEFINED);
         pg.loadAccumulatorInt(node, ResumeMode.NEXT);
         pg.storeAccumulator(node, this.resumeType);
         pg.moveVreg(node, nextMethod, iter.method());
@@ -152,7 +152,7 @@ export class AsyncGeneratorFunctionBuilder extends FunctionBuilder {
         let iterCompletion = new Label();
         // 7. Repeat
         pg.label(node, loopStart);
-        pg.storeConst(node, exitReturn, CacheList.False);
+        pg.storeConst(node, exitReturn, CacheList.FALSE);
 
         // a. If received.[[Type]] is normal, then
         pg.loadAccumulatorInt(node, ResumeMode.NEXT);
@@ -186,7 +186,7 @@ export class AsyncGeneratorFunctionBuilder extends FunctionBuilder {
         // c. Else,
         // i. Assert: received.[[Type]] is return
         pg.label(node, returnCompletion);
-        pg.storeConst(node, exitReturn, CacheList.True);
+        pg.storeConst(node, exitReturn, CacheList.TRUE);
         // ii. Let return be ? GetMethod(iterator, "return").
         iter.getMethod("return");
 
@@ -222,7 +222,7 @@ export class AsyncGeneratorFunctionBuilder extends FunctionBuilder {
         this.await(node);
 
         pg.generatorYield(node, this.funcObj);
-        pg.storeConst(node, done, CacheList.False);
+        pg.storeConst(node, done, CacheList.FALSE);
         pg.asyncgeneratorresolve(node, this.funcObj, this.resumeVal, done);
 
         this.resumeGenerator(node);
@@ -264,7 +264,7 @@ export class AsyncGeneratorFunctionBuilder extends FunctionBuilder {
         pg.freeTemps(method, iterator, nextResult, value, done, nextMethod, exitReturn);
     }
 
-    private handleAsyncYieldResume(node: ts.Node) {
+    private handleAsyncYieldResume(node: ts.Node): void {
         let pg = this.pg;
         let notRet = new Label();
         let normalCompletion = new Label();
@@ -310,7 +310,7 @@ export class AsyncGeneratorFunctionBuilder extends FunctionBuilder {
         pg.loadAccumulator(node, this.resumeVal);
     }
 
-    private handleMode(node: ts.Node) {
+    private handleMode(node: ts.Node): void {
         let pandaGen = this.pg;
 
         pandaGen.getResumeMode(node, this.funcObj);
@@ -330,12 +330,12 @@ export class AsyncGeneratorFunctionBuilder extends FunctionBuilder {
         pandaGen.loadAccumulator(node, this.resumeVal);
     }
 
-    resolve(node: ts.Node | NodeKind, value: VReg) {
+    resolve(node: ts.Node | NodeKind, value: VReg): void {
         let pandaGen = this.pg;
-        pandaGen.asyncgeneratorresolve(node, this.funcObj, value, getVregisterCache(pandaGen, CacheList.True));
+        pandaGen.asyncgeneratorresolve(node, this.funcObj, value, getVregisterCache(pandaGen, CacheList.TRUE));
     }
 
-    cleanUp(node: ts.Node) {
+    cleanUp(node: ts.Node): void {
         let pandaGen = this.pg;
         pandaGen.label(node, this.endLabel);
         // catch
@@ -343,7 +343,7 @@ export class AsyncGeneratorFunctionBuilder extends FunctionBuilder {
         pandaGen.generatorComplete(node, this.funcObj);
         pandaGen.loadAccumulator(node, this.resumeVal);
         pandaGen.asyncgeneratorreject(node, this.funcObj); // exception is in acc
-        pandaGen.return(NodeKind.Invalid);
+        pandaGen.return(NodeKind.INVALID);
         this.pg.freeTemps(this.funcObj, this.resumeVal, this.resumeType);
         new CatchTable(pandaGen, this.endLabel, new LabelPair(this.beginLabel, this.endLabel));
     }
diff --git a/ts2panda/src/function/functionBuilder.ts b/ts2panda/src/function/functionBuilder.ts
index 23a32bcc1a..646ab3e8a1 100644
--- a/ts2panda/src/function/functionBuilder.ts
+++ b/ts2panda/src/function/functionBuilder.ts
@@ -61,7 +61,7 @@ export class FunctionBuilder {
         pg.storeAccumulator(node, this.resumeVal);
     }
 
-    resumeGenerator(node: ts.Node | NodeKind) {
+    resumeGenerator(node: ts.Node | NodeKind): void {
         let pg = this.pg;
         pg.resumeGenerator(node, this.funcObj);
         pg.storeAccumulator(node, this.resumeVal);
@@ -69,12 +69,12 @@ export class FunctionBuilder {
         pg.storeAccumulator(node, this.resumeType);
     }
 
-    explicitReturn(node: ts.Node | NodeKind, empty ? : boolean) {
+    explicitReturn(node: ts.Node | NodeKind, empty ? : boolean): void {
         this.pg.return(node);
     }
 
-    implicitReturn(node: ts.Node | NodeKind) {
-        CmdOptions.isWatchEvaluateExpressionMode() ? this.pg.return(NodeKind.Invalid) : this.pg.returnUndefined(node);
+    implicitReturn(node: ts.Node | NodeKind): void {
+        CmdOptions.isWatchEvaluateExpressionMode() ? this.pg.return(NodeKind.INVALID) : this.pg.returnUndefined(node);
     }
 
     builderType(): FunctionBuilderType {
diff --git a/ts2panda/src/function/generatorFunctionBuilder.ts b/ts2panda/src/function/generatorFunctionBuilder.ts
index bbbd621c70..13a5d1050a 100644
--- a/ts2panda/src/function/generatorFunctionBuilder.ts
+++ b/ts2panda/src/function/generatorFunctionBuilder.ts
@@ -26,7 +26,7 @@ import { PandaGen } from "../pandagen";
 import { IteratorRecord, IteratorType, getIteratorRecord } from "../statement/forOfStatement";
 import { FunctionBuilder } from "./functionBuilder";
 
-enum ResumeMode { Return = 0, Throw, Next };
+enum ResumeMode { RETURN = 0, THROW, NEXT };
 
 /**
  * function *foo() {
@@ -43,13 +43,13 @@ export class GeneratorFunctionBuilder extends FunctionBuilder {
         this.compiler = compiler;
     }
 
-    prepare(node: ts.Node) {
+    prepare(node: ts.Node): void {
         let pandaGen = this.pg;
 
         // backend handle funcobj, frontend set undefined
         pandaGen.createGeneratorObj(node, getVregisterCache(pandaGen, CacheList.FUNC));
         pandaGen.storeAccumulator(node, this.funcObj);
-        pandaGen.loadAccumulator(node, getVregisterCache(pandaGen, CacheList.undefined));
+        pandaGen.loadAccumulator(node, getVregisterCache(pandaGen, CacheList.UNDEFINED));
         pandaGen.suspendGenerator(node, this.funcObj);
         pandaGen.resumeGenerator(node, this.funcObj);
         pandaGen.storeAccumulator(node, this.resumeVal);
@@ -57,21 +57,21 @@ export class GeneratorFunctionBuilder extends FunctionBuilder {
         this.handleMode(node);
     }
 
-    explicitReturn(node: ts.Node | NodeKind, empty ? : boolean) {
+    explicitReturn(node: ts.Node | NodeKind, empty ? : boolean): void {
         this.pg.return(node);
     }
 
-    implicitReturn(node: ts.Node | NodeKind) {
-        CmdOptions.isWatchEvaluateExpressionMode() ? this.pg.return(NodeKind.Invalid) : this.pg.returnUndefined(node);
+    implicitReturn(node: ts.Node | NodeKind): void {
+        CmdOptions.isWatchEvaluateExpressionMode() ? this.pg.return(NodeKind.INVALID) : this.pg.returnUndefined(node);
     }
 
-    yield(node: ts.Node) {
+    yield(node: ts.Node): void {
         let pandaGen = this.pg;
         let iterRslt = pandaGen.getTemp();
         let value = pandaGen.getTemp();
 
         pandaGen.storeAccumulator(node, value);
-        pandaGen.Createiterresultobj(node, value, getVregisterCache(pandaGen, CacheList.False));
+        pandaGen.Createiterresultobj(node, value, getVregisterCache(pandaGen, CacheList.FALSE));
         pandaGen.suspendGenerator(node, this.funcObj);
         pandaGen.freeTemps(iterRslt, value);
 
@@ -81,7 +81,7 @@ export class GeneratorFunctionBuilder extends FunctionBuilder {
         this.handleMode(node);
     }
 
-    yieldStar(expr: ts.YieldExpression) {
+    yieldStar(expr: ts.YieldExpression): void {
         let pandaGen = this.pg;
         let method = pandaGen.getTemp();
         let object = pandaGen.getTemp();
@@ -93,25 +93,25 @@ export class GeneratorFunctionBuilder extends FunctionBuilder {
         let callreturnLabel = new Label();
         let callthrowLabel = new Label();
         let iteratorCompletionLabel = new Label();
-        let exitLabel_return = new Label();
-        let exitLabel_throw = new Label();
-        let exitLabel_value = new Label();
-        let exitLabel_TypeError = new Label();
+        let exitLabelReturn = new Label();
+        let exitLabelThrow = new Label();
+        let exitLabelValue = new Label();
+        let exitLabelTypeError = new Label();
 
         // get innerIterator & iterator.[[Nextmethod]] (spec 4 & 5), support async in the future
         let type: IteratorType = IteratorType.Normal;
         let iterator: IteratorRecord = getIteratorRecord(pandaGen, expr, method, object, type);
 
         // init receivedValue with Undefined (spec 6)
-        pandaGen.moveVreg(expr, receivedValue, getVregisterCache(pandaGen, CacheList.undefined));
+        pandaGen.moveVreg(expr, receivedValue, getVregisterCache(pandaGen, CacheList.UNDEFINED));
 
         // init modeType with Next (spec 6)
-        pandaGen.loadAccumulatorInt(expr, ResumeMode.Next);
+        pandaGen.loadAccumulatorInt(expr, ResumeMode.NEXT);
         pandaGen.storeAccumulator(expr, modeType);
 
         // starts executeing iterator.[[method]] (spec 7)
         pandaGen.label(expr, loopStartLabel);
-        pandaGen.loadAccumulatorInt(expr, ResumeMode.Next);
+        pandaGen.loadAccumulatorInt(expr, ResumeMode.NEXT);
         pandaGen.condition(expr, ts.SyntaxKind.EqualsEqualsToken, modeType, callreturnLabel);
 
         // call next
@@ -120,19 +120,19 @@ export class GeneratorFunctionBuilder extends FunctionBuilder {
 
         // call return
         pandaGen.label(expr, callreturnLabel);
-        pandaGen.loadAccumulatorInt(expr, ResumeMode.Return);
+        pandaGen.loadAccumulatorInt(expr, ResumeMode.RETURN);
         pandaGen.condition(expr, ts.SyntaxKind.EqualsEqualsToken, modeType, callthrowLabel);
 
         pandaGen.loadObjProperty(expr, iterator.getObject(), "return");
         pandaGen.storeAccumulator(expr, method);
 
         // whether iterator.[[return]] exists
-        pandaGen.condition(expr, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.undefined), exitLabel_return);
+        pandaGen.condition(expr, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.UNDEFINED), exitLabelReturn);
         pandaGen.call(expr, [method, iterator.getObject(), receivedValue], true);
         pandaGen.branch(expr, iteratorCompletionLabel);
 
         // no return method
-        pandaGen.label(expr, exitLabel_return);
+        pandaGen.label(expr, exitLabelReturn);
 
         // if there are finally blocks, should implement these at first.
         this.compiler.compileFinallyBeforeCFC(
@@ -151,19 +151,19 @@ export class GeneratorFunctionBuilder extends FunctionBuilder {
         pandaGen.storeAccumulator(expr, method);
 
         // whether iterator.[[throw]] exists
-        pandaGen.condition(expr, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.undefined), exitLabel_throw);
+        pandaGen.condition(expr, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.UNDEFINED), exitLabelThrow);
         pandaGen.call(expr, [method, iterator.getObject(), receivedValue], true);
         pandaGen.branch(expr, iteratorCompletionLabel);
 
         // NOTE: If iterator does not have a throw method, this throw is
         // going to terminate the yield* loop. But first we need to give
         // iterator a chance to clean up.
-        pandaGen.label(expr, exitLabel_throw);
+        pandaGen.label(expr, exitLabelThrow);
         pandaGen.loadObjProperty(expr, iterator.getObject(), "return");
         pandaGen.storeAccumulator(expr, method);
 
         // whether iterator.[[return]] exists
-        pandaGen.condition(expr, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.undefined), exitLabel_TypeError);
+        pandaGen.condition(expr, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.UNDEFINED), exitLabelTypeError);
 
         // [[return]] exists
         pandaGen.call(expr, [method, iterator.getObject()], true);
@@ -172,7 +172,7 @@ export class GeneratorFunctionBuilder extends FunctionBuilder {
         pandaGen.throwIfNotObject(expr, innerResult);
         pandaGen.freeTemps(innerResult);
 
-        pandaGen.label(expr, exitLabel_TypeError);
+        pandaGen.label(expr, exitLabelTypeError);
         pandaGen.throwThrowNotExist(expr);
 
         // iteratorCompletion
@@ -181,7 +181,7 @@ export class GeneratorFunctionBuilder extends FunctionBuilder {
         pandaGen.throwIfNotObject(expr, this.resumeVal);
 
         pandaGen.loadObjProperty(expr, this.resumeVal, "done");
-        pandaGen.jumpIfTrue(expr, exitLabel_value);
+        pandaGen.jumpIfTrue(expr, exitLabelValue);
 
         pandaGen.loadAccumulator(expr, this.resumeVal);
         pandaGen.suspendGenerator(expr, this.funcObj);
@@ -196,11 +196,11 @@ export class GeneratorFunctionBuilder extends FunctionBuilder {
         // produce a value.
         let outputLabel = new Label();
 
-        pandaGen.label(expr, exitLabel_value);
+        pandaGen.label(expr, exitLabelValue);
         pandaGen.loadObjProperty(expr, this.resumeVal, "value");
         let outputResult = pandaGen.getTemp();
         pandaGen.storeAccumulator(expr, outputResult);
-        pandaGen.loadAccumulatorInt(expr, ResumeMode.Return);
+        pandaGen.loadAccumulatorInt(expr, ResumeMode.RETURN);
         pandaGen.condition(expr, ts.SyntaxKind.EqualsEqualsToken, modeType, outputLabel);
 
         this.compiler.compileFinallyBeforeCFC(
@@ -217,7 +217,7 @@ export class GeneratorFunctionBuilder extends FunctionBuilder {
         pandaGen.freeTemps(method, object, receivedValue, modeType, outputResult);
     }
 
-    private handleMode(node: ts.Node) {
+    private handleMode(node: ts.Node): void {
         let pandaGen = this.pg;
 
         let modeType = pandaGen.getTemp();
@@ -226,7 +226,7 @@ export class GeneratorFunctionBuilder extends FunctionBuilder {
         pandaGen.storeAccumulator(node, modeType);
 
         // .return(value)
-        pandaGen.loadAccumulatorInt(node, ResumeMode.Return);
+        pandaGen.loadAccumulatorInt(node, ResumeMode.RETURN);
 
         let notRetLabel = new Label();
 
@@ -245,7 +245,7 @@ export class GeneratorFunctionBuilder extends FunctionBuilder {
         // .throw(value)
         pandaGen.label(node, notRetLabel);
 
-        pandaGen.loadAccumulatorInt(node, ResumeMode.Throw);
+        pandaGen.loadAccumulatorInt(node, ResumeMode.THROW);
 
         let notThrowLabel = new Label();
 
@@ -260,7 +260,7 @@ export class GeneratorFunctionBuilder extends FunctionBuilder {
         pandaGen.loadAccumulator(node, this.resumeVal);
     }
 
-    cleanUp() {
+    cleanUp(): void {
         this.pg.freeTemps(this.funcObj, this.resumeVal);
     }
 }
diff --git a/ts2panda/src/hoisting.ts b/ts2panda/src/hoisting.ts
index e544b95c25..8ff83b5dbd 100644
--- a/ts2panda/src/hoisting.ts
+++ b/ts2panda/src/hoisting.ts
@@ -34,7 +34,7 @@ import {
 import { ModuleVariable } from "./variable";
 
 export function hoisting(rootNode: ts.SourceFile | ts.FunctionLikeDeclaration, pandaGen: PandaGen,
-    recorder: Recorder, compiler: Compiler) {
+    recorder: Recorder, compiler: Compiler): void {
     let variableScope = <VariableScope>recorder.getScopeOfNode(rootNode);
     let hoistDecls = recorder.getHoistDeclsOfScope(variableScope);
 
@@ -50,40 +50,40 @@ export function hoisting(rootNode: ts.SourceFile | ts.FunctionLikeDeclaration, p
     });
 }
 
-export function hoistVar(decl: VarDecl, scope: Scope, pandaGen: PandaGen) {
+export function hoistVar(decl: VarDecl, scope: Scope, pandaGen: PandaGen): void {
     let name = decl.name;
 
     if (scope instanceof GlobalScope) {
-        pandaGen.loadAccumulator(decl.node, getVregisterCache(pandaGen, CacheList.undefined));
+        pandaGen.loadAccumulator(decl.node, getVregisterCache(pandaGen, CacheList.UNDEFINED));
         pandaGen.storeGlobalVar(decl.node, name);
     } else if (scope instanceof FunctionScope || scope instanceof ModuleScope) {
         let v: ModuleVariable = <ModuleVariable>(scope.findLocal(name)!);
-        pandaGen.loadAccumulator(NodeKind.FirstNodeOfFunction, getVregisterCache(pandaGen, CacheList.undefined));
+        pandaGen.loadAccumulator(NodeKind.FIRST_NODE_OF_FUNCTION, getVregisterCache(pandaGen, CacheList.UNDEFINED));
         if (decl.isModule !== ModuleVarKind.NOT) {
-            pandaGen.storeModuleVariable(NodeKind.FirstNodeOfFunction, v);
+            pandaGen.storeModuleVariable(NodeKind.FIRST_NODE_OF_FUNCTION, v);
         } else {
-            pandaGen.storeAccToLexEnv(NodeKind.FirstNodeOfFunction, scope, 0, v, true);
+            pandaGen.storeAccToLexEnv(NodeKind.FIRST_NODE_OF_FUNCTION, scope, 0, v, true);
         }
     } else {
         throw new Error("Wrong scope to hoist");
     }
 }
 
-export function hoistFunction(decl: FuncDecl, scope: Scope, pandaGen: PandaGen, compiler: Compiler, compilerDriver: CompilerDriver) {
+export function hoistFunction(decl: FuncDecl, scope: Scope, pandaGen: PandaGen, compiler: Compiler, compilerDriver: CompilerDriver): void {
     let funcName = decl.name;
     let internalName = compilerDriver.getFuncInternalName(<ts.FunctionLikeDeclaration>decl.node, compiler.getRecorder());
     let env = compiler.getCurrentEnv();
 
     if (scope instanceof GlobalScope) {
-        pandaGen.defineFunction(NodeKind.FirstNodeOfFunction, <ts.FunctionDeclaration>decl.node, internalName);
-        pandaGen.storeGlobalVar(NodeKind.FirstNodeOfFunction, funcName);
+        pandaGen.defineFunction(NodeKind.FIRST_NODE_OF_FUNCTION, <ts.FunctionDeclaration>decl.node, internalName);
+        pandaGen.storeGlobalVar(NodeKind.FIRST_NODE_OF_FUNCTION, funcName);
     } else if ((scope instanceof FunctionScope) || (scope instanceof LocalScope) || (scope instanceof ModuleScope)) {
         let v: ModuleVariable = <ModuleVariable>(scope.findLocal(funcName)!);
-        pandaGen.defineFunction(NodeKind.FirstNodeOfFunction, <ts.FunctionDeclaration>decl.node, internalName);
+        pandaGen.defineFunction(NodeKind.FIRST_NODE_OF_FUNCTION, <ts.FunctionDeclaration>decl.node, internalName);
         if (decl.isModule !== ModuleVarKind.NOT) {
-            pandaGen.storeModuleVariable(NodeKind.FirstNodeOfFunction, v);
+            pandaGen.storeModuleVariable(NodeKind.FIRST_NODE_OF_FUNCTION, v);
         } else {
-            pandaGen.storeAccToLexEnv(NodeKind.FirstNodeOfFunction, scope, 0, v, true);
+            pandaGen.storeAccToLexEnv(NodeKind.FIRST_NODE_OF_FUNCTION, scope, 0, v, true);
         }
     } else {
         throw new Error("Wrong scope to hoist");
@@ -91,7 +91,7 @@ export function hoistFunction(decl: FuncDecl, scope: Scope, pandaGen: PandaGen,
 }
 
 // this function is called when hoisting function inside blocks
-export function hoistFunctionInBlock(scope: Scope, pandaGen: PandaGen, strictMode: boolean, compiler: Compiler) {
+export function hoistFunctionInBlock(scope: Scope, pandaGen: PandaGen, strictMode: boolean, compiler: Compiler): void {
     let decls = scope.getDecls();
     let funcToHoist = new Array<FuncDecl>();
     for (let i = 0; i < decls.length; i++) {
diff --git a/ts2panda/src/index.ts b/ts2panda/src/index.ts
index 92648846c0..1fa8b0cfa7 100644
--- a/ts2panda/src/index.ts
+++ b/ts2panda/src/index.ts
@@ -42,7 +42,7 @@ import {
     resetUniqueNameIndex
 } from "./base/util";
 
-function checkIsGlobalDeclaration(sourceFile: ts.SourceFile) {
+function checkIsGlobalDeclaration(sourceFile: ts.SourceFile): boolean {
     for (let statement of sourceFile.statements) {
         if (statement.modifiers) {
             for (let modifier of statement.modifiers) {
@@ -59,7 +59,7 @@ function checkIsGlobalDeclaration(sourceFile: ts.SourceFile) {
     return true;
 }
 
-function generateDTs(node: ts.SourceFile, options: ts.CompilerOptions) {
+function generateDTs(node: ts.SourceFile, options: ts.CompilerOptions): void {
     let outputBinName = getOutputBinName(node);
     let compilerDriver = new CompilerDriver(outputBinName, getRecordName(node));
     CompilerDriver.srcNode = node;
@@ -68,7 +68,7 @@ function generateDTs(node: ts.SourceFile, options: ts.CompilerOptions) {
     compilerDriver.showStatistics();
 }
 
-function main(fileNames: string[], options: ts.CompilerOptions, inputJsonFiles?: string[], cmdArgsSet?: Map<string, string[]>) {
+function main(fileNames: string[], options: ts.CompilerOptions, inputJsonFiles?: string[], cmdArgsSet?: Map<string, string[]>): void {
     const host = ts.createCompilerHost(options);
     if (!CmdOptions.needGenerateTmpFile()) {
         host.writeFile = () => {};
@@ -140,7 +140,7 @@ function main(fileNames: string[], options: ts.CompilerOptions, inputJsonFiles?:
                                 initTs2abcProcessState = true;
                             }
                             let specifiedCmdArgs = cmdArgsSet.get(node.fileName);
-                            if (specifiedCmdArgs == undefined) {
+                            if (specifiedCmdArgs === undefined) {
                                 return node;
                             }
                         }
@@ -211,7 +211,7 @@ function main(fileNames: string[], options: ts.CompilerOptions, inputJsonFiles?:
     });
 }
 
-function transformSourcefilesList(parsed: ts.ParsedCommandLine | undefined) {
+function transformSourcefilesList(parsed: ts.ParsedCommandLine | undefined): void {
     let inputFile = CmdOptions.getCompileFilesList();
     let sourceFileInfoArray = [];
     try {
@@ -219,7 +219,7 @@ function transformSourcefilesList(parsed: ts.ParsedCommandLine | undefined) {
     } catch(err) {
         throw err;
     }
-    if (sourceFileInfoArray.length == 0) return;
+    if (sourceFileInfoArray.length === 0) return;
 
     let files: string[] = parsed.fileNames;
     let inputJsonFiles: string[] = [];
@@ -234,7 +234,7 @@ function transformSourcefilesList(parsed: ts.ParsedCommandLine | undefined) {
 
         let inputFileName = sourceFileInfo[0];
         let inputFileSuffix = inputFileName.substring(inputFileName.lastIndexOf(".") + 1);
-        if (inputFileSuffix == "json") {
+        if (inputFileSuffix === "json") {
             inputJsonFiles.push(inputFileName);
         } else {
             files.unshift(inputFileName);
@@ -283,7 +283,7 @@ function getDtsFiles(libDir: string): string[] {
     return dtsFiles;
 }
 
-function specifyCustomLib(customLib) {
+function specifyCustomLib(customLib): void {
     Compiler.Options.Default["lib"] = customLib;
     let curFiles = fs.readdirSync(__dirname);
     const { execSync } = require('child_process');
@@ -318,10 +318,10 @@ const es2abcDebuggerEvaluateFlag = "--debugger-evaluate-expression";
 const es2abcBase64Output = "--base64Output";
 // need to specify the record name as 'Base64Output' in es2abc's commandline; cancel the opMergeAbc option
 
-function callEs2pandaToolChain(ideInputStr: string) {
+function callEs2pandaToolChain(ideInputStr: string): void {
     let commandLine = "\"" + es2abcBinaryPath + es2abcBinaryName + "\" " + es2abcBase64Input + " \"" + ideInputStr
                       + "\" " + es2abcDebuggerEvaluateFlag + " " + es2abcBase64Output;
-    var exec = require('child_process').exec;
+    let exec = require('child_process').exec;
     exec(`${commandLine}`, function(error, stdout) {
         if (error) {
             console.log("generate abc file failed, please check the input string and syntax of the expression");
@@ -331,7 +331,7 @@ function callEs2pandaToolChain(ideInputStr: string) {
     });
 }
 
-function updateWatchJsFile() {
+function updateWatchJsFile(): void {
     let ideInputStr = CmdOptions.getEvaluateExpression();
     if (CmdOptions.watchViaEs2pandaToolchain()) {
         callEs2pandaToolChain(ideInputStr);
@@ -385,7 +385,7 @@ function updateWatchJsFile() {
 }
 
 function compileWatchExpression(jsFileName: string, errorMsgFileName: string, options: ts.CompilerOptions,
-                                watchedProgram: ts.Program) {
+                                watchedProgram: ts.Program): void {
     CmdOptions.setWatchEvaluateExpressionArgs(['','']);
     let fileName = watchFileName + ".js";
     let errorMsgRecordFlag = false;
@@ -412,7 +412,7 @@ function compileWatchExpression(jsFileName: string, errorMsgFileName: string, op
                 // @ts-ignore
                 (ctx: ts.TransformationContext) => {
                     return (node: ts.SourceFile) => {
-                        if (path.basename(node.fileName) == fileName) { node = sourceFile; }
+                        if (path.basename(node.fileName) === fileName) { node = sourceFile; }
                         let outputBinName = getOutputBinName(node);
                         let compilerDriver = new CompilerDriver(outputBinName, watchOutputFileName);
                         compilerDriver.compileForSyntaxCheck(node);
@@ -453,7 +453,7 @@ function compileWatchExpression(jsFileName: string, errorMsgFileName: string, op
     );
 }
 
-function launchWatchEvaluateDeamon(parsed: ts.ParsedCommandLine | undefined) {
+function launchWatchEvaluateDeamon(parsed: ts.ParsedCommandLine | undefined): void {
     if (CmdOptions.watchViaEs2pandaToolchain()) {
         console.log("startWatchingSuccess supportTimeout");
         return;
@@ -479,7 +479,7 @@ function launchWatchEvaluateDeamon(parsed: ts.ParsedCommandLine | undefined) {
         if (+curr.mtime <= +prev.mtime) {
             throw new Error("watched js file has not been initialized");
         }
-        if (fs.readFileSync(jsFileName).toString() == stopWatchingStr) {
+        if (fs.readFileSync(jsFileName).toString() === stopWatchingStr) {
             fs.unwatchFile(jsFileName);
             console.log("stopWatchingSuccess");
             return;
@@ -495,7 +495,7 @@ function launchWatchEvaluateDeamon(parsed: ts.ParsedCommandLine | undefined) {
     });
 }
 
-function checkDiagnosticsError(program: ts.Program) {
+function checkDiagnosticsError(program: ts.Program): boolean {
     let diagnosticsFlag = false;
     let allDiagnostics = ts
         .getPreEmitDiagnostics(program);
diff --git a/ts2panda/src/jshelpers.d.ts b/ts2panda/src/jshelpers.d.ts
index 8e45aa3995..b572ca026f 100644
--- a/ts2panda/src/jshelpers.d.ts
+++ b/ts2panda/src/jshelpers.d.ts
@@ -24,7 +24,8 @@ export function getFlowNode(stmt: ts.Statement): ts.Node;
 export function bindSourceFile(sourceFile: ts.SourceFile, options: ts.CompilerOptions);
 export function createDiagnosticForNode(node: ts.Node, message: ts.DiagnosticMessage, ...args: (string | number | undefined)[]): ts.DiagnosticWithLocation;
 export function createCompilerDiagnostic(message: ts.DiagnosticMessage, ...args: (string | number | undefined)[]): ts.Diagnostic;
-export function createFileDiagnostic(file: ts.SourceFile, start: number, length: number, message: ts.DiagnosticMessage, ...args: (string | number | undefined)[]): ts.DiagnosticWithLocation;
+export function createFileDiagnostic(file: ts.SourceFile, start: number, length: number, message: ts.DiagnosticMessage,
+                                     ...args: (string | number | undefined)[]): ts.DiagnosticWithLocation;
 export function isEffectiveStrictModeSourceFile(node: ts.SourceFile, compilerOptions: ts.CompilerOptions): boolean;
 export function getErrorSpanForNode(sourceFile: ts.SourceFile, node: ts.Node): ts.TextSpan;
 export function getSpanOfTokenAtPosition(sourceFile: ts.SourceFile, pos: number): ts.TextSpan;
diff --git a/ts2panda/src/lexenv.ts b/ts2panda/src/lexenv.ts
index 0b9ab61236..550b0649f4 100644
--- a/ts2panda/src/lexenv.ts
+++ b/ts2panda/src/lexenv.ts
@@ -49,7 +49,7 @@ abstract class VariableAccessBase {
         this.level = level;
     }
 
-    isLexVar() {
+    isLexVar(): boolean {
         return this.variable.isLexVar;
     }
 
@@ -166,7 +166,7 @@ export class VariableAcessStore extends VariableAccessBase {
             if (!this.isDeclaration) {
                 /**
                  * check TDZ first
-                 * If acc == hole -> throw reference error
+                 * If acc === hole -> throw reference error
                  * else -> execute the next insn
                 */
                 insns.push(loadLexicalVar(this.level, slot));
@@ -187,7 +187,7 @@ export class VariableAcessStore extends VariableAccessBase {
     }
 }
 
-function checkConstAssignment(pg: PandaGen, v: Variable, expansion: IRNode[], node: ts.Node | NodeKind) {
+function checkConstAssignment(pg: PandaGen, v: Variable, expansion: IRNode[], node: ts.Node | NodeKind): void {
     let nameReg = pg.getTemp();
     if (v.isConst()) {
         expansion.push(loadAccumulatorString(v.getName()));
@@ -195,12 +195,12 @@ function checkConstAssignment(pg: PandaGen, v: Variable, expansion: IRNode[], no
         expansion.push(throwConstAssignment(nameReg));
     }
 
-    if (v.isClass() && node != NodeKind.FirstNodeOfFunction &&
-        node != NodeKind.Invalid && node != NodeKind.Normal) {
+    if (v.isClass() && node != NodeKind.FIRST_NODE_OF_FUNCTION &&
+        node != NodeKind.INVALID && node != NodeKind.NORMAL) {
         let className = v.getName();
         while (node) {
             if (ts.isClassLike(node) && node.name &&
-                jshelpers.getTextOfIdentifierOrLiteral(node.name) == className) {
+                jshelpers.getTextOfIdentifierOrLiteral(node.name) === className) {
                 break;
             }
 
diff --git a/ts2panda/src/lexicalBinder.ts b/ts2panda/src/lexicalBinder.ts
index 37aaa5809a..61f7e16870 100644
--- a/ts2panda/src/lexicalBinder.ts
+++ b/ts2panda/src/lexicalBinder.ts
@@ -41,11 +41,11 @@ export class LexicalBinder {
         this.recorder = recorder;
     }
 
-    resolve() {
+    resolve(): void {
         this.resolveIdentReference(this.srcFile, this.recorder.getScopeOfNode(this.srcFile));
     }
 
-    resolveIdentReference(node: ts.Node, scope: Scope) {
+    resolveIdentReference(node: ts.Node, scope: Scope): void {
         node.forEachChild((child) => {
             let tmp = this.recorder.getScopeOfNode(child);
             let newScope = tmp ? tmp : scope;
@@ -135,7 +135,7 @@ export class LexicalBinder {
         });
     }
 
-    lookUpLexicalReference(name: string, scope: Scope) {
+    lookUpLexicalReference(name: string, scope: Scope): void {
         let declPosInfo = scope.resolveDeclPos(name);
         if (!declPosInfo.isLexical) { // if find declaration position in the current function
             return;
@@ -154,7 +154,7 @@ export class LexicalBinder {
         declPosInfo.v.setLexVar(declPosInfo.defLexicalScope);
     }
 
-    setMandatoryParamLexical(name: string, scope: VariableScope) {
+    setMandatoryParamLexical(name: string, scope: VariableScope): void {
         if (ts.isArrowFunction(scope.getBindingNode())) {
             throw new Error("Arrow function should not be processed");
         }
@@ -163,7 +163,7 @@ export class LexicalBinder {
         v.setLexVar(scope);
     }
 
-    setMandatoryParamLexicalForNCFuncInDebug(scope: VariableScope) {
+    setMandatoryParamLexicalForNCFuncInDebug(scope: VariableScope): void {
         if (!ts.isArrowFunction(scope.getBindingNode())) {
             throw new Error("Non-ArrowFunction should not be processed");
         }
@@ -205,7 +205,7 @@ export class LexicalBinder {
     hasDeclarationParent(id: ts.Identifier): boolean {
         let parent = id.parent;
         if (ts.isBindingElement(parent) &&
-            parent.name == id) {
+            parent.name === id) {
             while (parent && !ts.isVariableDeclaration(parent)) {
                 parent = parent.parent;
             }
@@ -215,16 +215,16 @@ export class LexicalBinder {
 
         if ((ts.isVariableDeclaration(parent) || ts.isClassDeclaration(parent) ||
              ts.isClassExpression(parent) || ts.isFunctionLike(parent))
-             && parent.name == id) {
+             && parent.name === id) {
             return true;
         }
 
         return false;
     }
 
-    isPropertyName(id: ts.Identifier) {
+    isPropertyName(id: ts.Identifier): boolean {
         let parent = id.parent;
-        if (ts.isPropertyAccessExpression(parent) && (parent.name == id)) { // eg. a.b -> b is the property name
+        if (ts.isPropertyAccessExpression(parent) && (parent.name === id)) { // eg. a.b -> b is the property name
             return true;
         }
 
diff --git a/ts2panda/src/log.ts b/ts2panda/src/log.ts
index 88a49b074c..f9790f86fd 100644
--- a/ts2panda/src/log.ts
+++ b/ts2panda/src/log.ts
@@ -17,7 +17,7 @@
 import * as ts from "typescript";
 import { CmdOptions } from "./cmdOptions";
 
-export function LOGD(tag: any, ...args: any[]) {
+export function LOGD(tag: any, ...args: any[]): void {
     if (CmdOptions.isEnableDebugLog()) {
         if (tag) {
             console.log(tag + ": " + args);
@@ -27,7 +27,7 @@ export function LOGD(tag: any, ...args: any[]) {
     }
 }
 
-export function LOGE(tag: any, ...args: any[]) {
+export function LOGE(tag: any, ...args: any[]): void {
     if (tag) {
         console.error(tag + ": " + args);
     } else {
@@ -35,11 +35,11 @@ export function LOGE(tag: any, ...args: any[]) {
     }
 }
 
-export function printAstRecursively(node: ts.Node, indentLevel: number, sourceFile: ts.SourceFile) {
+export function printAstRecursively(node: ts.Node, indentLevel: number, sourceFile: ts.SourceFile): void {
     if (CmdOptions.isEnableDebugLog()) {
         const indentation = "-".repeat(indentLevel);
         let nodeContent = ts.SyntaxKind[node.kind] + ": ";
-        if (node.kind == ts.SyntaxKind.Identifier) {
+        if (node.kind === ts.SyntaxKind.Identifier) {
             // @ts-ignore
             nodeContent += (<ts.Identifier>node).escapedText;
         }
diff --git a/ts2panda/src/modules.ts b/ts2panda/src/modules.ts
index ddb83fa5f6..152c840fcc 100644
--- a/ts2panda/src/modules.ts
+++ b/ts2panda/src/modules.ts
@@ -19,7 +19,7 @@ import * as jshelpers from "./jshelpers";
 import { DiagnosticCode, DiagnosticError } from "./diagnostic";
 
 export class ModuleStmt {
-    private node: ts.Node
+    private node: ts.Node;
     private moduleRequest: string;
     private namespace: string = "";
     private bingdingNameMap: Map<string, string> = new Map<string, string>();
@@ -31,38 +31,38 @@ export class ModuleStmt {
         this.moduleRequest = moduleRequest;
     }
 
-    getNode() {
+    getNode(): ts.Node {
         return this.node;
     }
 
-    getModuleRequest() {
+    getModuleRequest(): string {
         return this.moduleRequest;
     }
 
-    addLocalName(localName: string, importName: string) {
+    addLocalName(localName: string, importName: string): void {
         if (this.bingdingNameMap.has(localName)) {
             throw new DiagnosticError(this.node, DiagnosticCode.Duplicate_identifier_0, jshelpers.getSourceFileOfNode(this.node), [localName]);
         }
         this.bingdingNameMap.set(localName, importName);
     }
 
-    getBindingNameMap() {
+    getBindingNameMap(): Map<string, string> {
         return this.bingdingNameMap;
     }
 
-    addNodeMap(name: ts.Node, propertyName: ts.Node) {
+    addNodeMap(name: ts.Node, propertyName: ts.Node): void {
         this.bingdingNodeMap.set(name, propertyName);
     }
 
-    getBindingNodeMap() {
+    getBindingNodeMap(): Map<ts.Node, ts.Node> {
         return this.bingdingNodeMap;
     }
 
-    setNameSpace(namespace: string) {
+    setNameSpace(namespace: string): void {
         this.namespace = namespace;
     }
 
-    getNameSpace() {
+    getNameSpace(): string {
         return this.namespace;
     }
 
@@ -70,7 +70,7 @@ export class ModuleStmt {
         this.isCopy = isCopy;
     }
 
-    getCopyFlag() {
+    getCopyFlag(): boolean {
         return this.isCopy;
     }
 }
diff --git a/ts2panda/src/pandagen.ts b/ts2panda/src/pandagen.ts
index dd46cd8f7a..8d5d7e839c 100644
--- a/ts2panda/src/pandagen.ts
+++ b/ts2panda/src/pandagen.ts
@@ -243,7 +243,7 @@ export class PandaGen {
     }
 
     public appendScopeInfo(lexVarInfo: Map<string, number>): string | undefined {
-        if (lexVarInfo.size == 0) {
+        if (lexVarInfo.size === 0) {
             return undefined;
         }
 
@@ -272,7 +272,7 @@ export class PandaGen {
 
         if (node.modifiers) {
             for (let i = 0; i < node.modifiers.length; i++) {
-                if (node.modifiers[i].kind == ts.SyntaxKind.AsyncKeyword) {
+                if (node.modifiers[i].kind === ts.SyntaxKind.AsyncKeyword) {
                     if (node.asteriskToken) {
                         this.funcKind = FunctionKind.ASYNC_GENERATOR_FUNCTION;
                         return;
@@ -397,22 +397,22 @@ export class PandaGen {
         PandaGen.literalArrayBuffer[index] = typeBuf;
     }
 
-    getFirstStmt() {
+    getFirstStmt(): ts.Statement {
         return this.firstStmt;
     }
 
-    setFirstStmt(firstStmt: ts.Statement) {
+    setFirstStmt(firstStmt: ts.Statement): void {
         if (this.firstStmt) {
             return;
         }
         this.firstStmt = firstStmt;
     }
 
-    getVregisterCache() {
+    getVregisterCache(): VregisterCache {
         return this.vregisterCache;
     }
 
-    getCatchMap() {
+    getCatchMap(): Map<Label, CatchTable> {
         return this.catchMap;
     }
 
@@ -424,7 +424,7 @@ export class PandaGen {
         return this.variableDebugInfoArray;
     }
 
-    addDebugVariableInfo(variable: VariableDebugInfo) {
+    addDebugVariableInfo(variable: VariableDebugInfo): void {
         this.variableDebugInfoArray.push(variable);
     }
 
@@ -454,7 +454,7 @@ export class PandaGen {
         return retval;
     }
 
-    freeTemps(...temps: VReg[]) {
+    freeTemps(...temps: VReg[]): void {
         this.temps.unshift(...temps);
     }
 
@@ -462,11 +462,11 @@ export class PandaGen {
         return this.insns;
     }
 
-    setInsns(insns: IRNode[]) {
+    setInsns(insns: IRNode[]): void {
         this.insns = insns;
     }
 
-    printInsns() {
+    printInsns(): void {
         LOGE("function " + this.internalName + "() {");
         this.getInsns().forEach(ins => {
             LOGE(ins.toString());
@@ -474,7 +474,7 @@ export class PandaGen {
         LOGE("}");
     }
 
-    setTotalRegsNum(num: number) {
+    setTotalRegsNum(num: number): void {
         this.totalRegsNum = num;
     }
 
@@ -482,7 +482,7 @@ export class PandaGen {
         return this.totalRegsNum;
     }
 
-    setParametersCount(count: number) {
+    setParametersCount(count: number): void {
         this.parametersCount = count;
     }
 
@@ -490,7 +490,7 @@ export class PandaGen {
         return this.parametersCount;
     }
 
-    setLocals(locals: VReg[]) {
+    setLocals(locals: VReg[]): void {
         this.locals = locals;
     }
 
@@ -502,19 +502,19 @@ export class PandaGen {
         return this.temps;
     }
 
-    getInstTypeMap() {
+    getInstTypeMap(): Map<IRNode, number> {
         return this.instTypeMap;
     }
 
-    getNode() {
+    getNode(): ts.SourceFile | ts.FunctionLikeDeclaration {
         return this.node;
     }
 
-    storeAccumulator(node: ts.Node | NodeKind, vreg: VReg) {
+    storeAccumulator(node: ts.Node | NodeKind, vreg: VReg): void {
         this.add(node, storeAccumulator(vreg));
     }
 
-    generatorYield(node: ts.Node, genObj: VReg) {
+    generatorYield(node: ts.Node, genObj: VReg): void {
         this.add(
             node,
             loadAccumulator(genObj),
@@ -522,7 +522,7 @@ export class PandaGen {
         )
     }
 
-    generatorComplete(node: ts.Node | NodeKind, genObj: VReg) {
+    generatorComplete(node: ts.Node | NodeKind, genObj: VReg): void {
         this.add(
             node,
             loadAccumulator(genObj),
@@ -530,7 +530,7 @@ export class PandaGen {
         )
     }
 
-    loadAccFromArgs(node: ts.Node) {
+    loadAccFromArgs(node: ts.Node): void {
         if ((<VariableScope>this.scope).getUseArgs()) {
             let v = this.scope!.findLocal(MandatoryArguments);
             if (this.scope instanceof FunctionScope) {
@@ -546,15 +546,15 @@ export class PandaGen {
         }
     }
 
-    deleteObjProperty(node: ts.Node, obj: VReg) {
+    deleteObjProperty(node: ts.Node, obj: VReg): void {
         this.add(node, deleteObjProperty(obj));
     }
 
-    loadAccumulator(node: ts.Node | NodeKind, vreg: VReg) {
+    loadAccumulator(node: ts.Node | NodeKind, vreg: VReg): void {
         this.add(node, loadAccumulator(vreg));
     }
 
-    createLexEnv(node: ts.Node, scope: VariableScope | LoopScope) {
+    createLexEnv(node: ts.Node, scope: VariableScope | LoopScope): void {
         let numVars = scope.getNumLexEnv();
         let scopeInfoId: string | undefined = undefined;
         let lexVarInfo = scope.getLexVarInfo();
@@ -568,21 +568,21 @@ export class PandaGen {
         )
     }
 
-    newLexicalEnv(node, numVars: number) {
+    newLexicalEnv(node, numVars: number): void {
         this.add(
             node,
             newLexicalEnv(numVars, undefined),
         )
     }
 
-    popLexicalEnv(node: ts.Node) {
+    popLexicalEnv(node: ts.Node): void {
         this.add(
             node,
             popLexicalEnv()
         )
     }
 
-    loadAccFromLexEnv(node: ts.Node, scope: Scope, level: number, v: Variable) {
+    loadAccFromLexEnv(node: ts.Node, scope: Scope, level: number, v: Variable): void {
         let expander = new VariableAccessLoad(scope, level, v);
         let insns = expander.expand(this);
         this.add(
@@ -591,7 +591,7 @@ export class PandaGen {
         );
     }
 
-    storeAccToLexEnv(node: ts.Node | NodeKind, scope: Scope, level: number, v: Variable, isDeclaration: boolean) {
+    storeAccToLexEnv(node: ts.Node | NodeKind, scope: Scope, level: number, v: Variable, isDeclaration: boolean): void {
         let expander = new VariableAcessStore(scope, level, v, isDeclaration, node);
         let insns = expander.expand(this);
         this.add(
@@ -600,7 +600,7 @@ export class PandaGen {
         )
     }
 
-    loadObjProperty(node: ts.Node, obj: VReg, prop: VReg | string | number) {
+    loadObjProperty(node: ts.Node, obj: VReg, prop: VReg | string | number): void {
         switch (typeof (prop)) {
             case "number": {
                 if (isInteger(prop)) {
@@ -625,7 +625,7 @@ export class PandaGen {
         }
     }
 
-    storeObjProperty(node: ts.Node | NodeKind, obj: VReg, prop: VReg | string | number) {
+    storeObjProperty(node: ts.Node | NodeKind, obj: VReg, prop: VReg | string | number): void {
         switch (typeof (prop)) {
             case "number":
                 if (isInteger(prop)) {
@@ -652,7 +652,7 @@ export class PandaGen {
         }
     }
 
-    storeOwnProperty(node: ts.Node | NodeKind, obj: VReg, prop: VReg | string | number, nameSetting: boolean = false) {
+    storeOwnProperty(node: ts.Node | NodeKind, obj: VReg, prop: VReg | string | number, nameSetting: boolean = false): void {
         switch (typeof prop) {
             case "number": {
                 if (isInteger(prop)) {
@@ -680,7 +680,7 @@ export class PandaGen {
         }
     }
 
-    private loadObjByName(node: ts.Node, obj: VReg, string_id: string) {
+    private loadObjByName(node: ts.Node, obj: VReg, string_id: string): void {
         this.add(
             node,
             loadAccumulator(obj),
@@ -688,14 +688,14 @@ export class PandaGen {
         );
     }
 
-    private storeObjByName(node: ts.Node | NodeKind, obj: VReg, string_id: string) {
+    private storeObjByName(node: ts.Node | NodeKind, obj: VReg, string_id: string): void {
         this.add(
             node,
             storeObjByName(obj, string_id)
         );
     }
 
-    private loadObjByIndex(node: ts.Node, obj: VReg, index: number) {
+    private loadObjByIndex(node: ts.Node, obj: VReg, index: number): void {
         this.add(
             node,
             loadAccumulator(obj),
@@ -703,7 +703,7 @@ export class PandaGen {
         )
     }
 
-    private storeObjByIndex(node: ts.Node | NodeKind, obj: VReg, index: number) {
+    private storeObjByIndex(node: ts.Node | NodeKind, obj: VReg, index: number): void {
         this.add(
             node,
             storeObjByIndex(obj, index)
@@ -711,7 +711,7 @@ export class PandaGen {
     }
 
 
-    private loadObjByValue(node: ts.Node, obj: VReg, value: VReg) {
+    private loadObjByValue(node: ts.Node, obj: VReg, value: VReg): void {
         this.add(
             node,
             loadAccumulator(value),
@@ -719,27 +719,27 @@ export class PandaGen {
         )
     }
 
-    private storeObjByValue(node: ts.Node | NodeKind, obj: VReg, prop: VReg) {
+    private storeObjByValue(node: ts.Node | NodeKind, obj: VReg, prop: VReg): void {
         this.add(
             node,
             storeObjByValue(obj, prop)
         )
     }
 
-    private stOwnByName(node: ts.Node | NodeKind, obj: VReg, string_id: string, nameSetting: boolean) {
+    private stOwnByName(node: ts.Node | NodeKind, obj: VReg, string_id: string, nameSetting: boolean): void {
         this.add(node, storeOwnByName(obj, string_id, nameSetting));
     }
 
-    private stOwnByIndex(node: ts.Node | NodeKind, obj: VReg, index: number) {
+    private stOwnByIndex(node: ts.Node | NodeKind, obj: VReg, index: number): void {
         this.add(node, storeOwnByIndex(obj, index));
     }
 
-    private stOwnByValue(node: ts.Node | NodeKind, obj: VReg, value: VReg, nameSetting: boolean) {
+    private stOwnByValue(node: ts.Node | NodeKind, obj: VReg, value: VReg, nameSetting: boolean): void {
         this.add(node, storeOwnByValue(obj, value, nameSetting));
     }
 
-    loadByNameViaDebugger(node: ts.Node, string_id: string, boolVal: CacheList) {
-        this.loadObjProperty(node, getVregisterCache(this, CacheList.Global), "debuggerGetValue");
+    loadByNameViaDebugger(node: ts.Node, string_id: string, boolVal: CacheList): void {
+        this.loadObjProperty(node, getVregisterCache(this, CacheList.GLOBAL), "debuggerGetValue");
         let getValueReg = this.getTemp();
         this.storeAccumulator(node, getValueReg);
         let variableReg = this.getTemp();
@@ -752,15 +752,15 @@ export class PandaGen {
     }
 
     // eg. print
-    tryLoadGlobalByName(node: ts.Node, string_id: string) {
-        CmdOptions.isWatchEvaluateExpressionMode() ? this.loadByNameViaDebugger(node, string_id, CacheList.True)
-                                : this.add(node, tryLoadGlobalByName(string_id));
+    tryLoadGlobalByName(node: ts.Node, string_id: string): void {
+        CmdOptions.isWatchEvaluateExpressionMode() ? this.loadByNameViaDebugger(node, string_id, CacheList.TRUE) :
+                                                     this.add(node, tryLoadGlobalByName(string_id));
     }
 
-    storeByNameViaDebugger(node: ts.Node, string_id: string) {
+    storeByNameViaDebugger(node: ts.Node, string_id: string): void {
         let valueReg = this.getTemp();
         this.storeAccumulator(node, valueReg);
-        this.loadObjProperty(node, getVregisterCache(this, CacheList.Global), "debuggerSetValue");
+        this.loadObjProperty(node, getVregisterCache(this, CacheList.GLOBAL), "debuggerSetValue");
         let setValueReg = this.getTemp();
         this.storeAccumulator(node, setValueReg);
         let variableReg = this.getTemp();
@@ -771,68 +771,68 @@ export class PandaGen {
     }
 
     // eg. a = 1
-    tryStoreGlobalByName(node: ts.Node, string_id: string) {
-        CmdOptions.isWatchEvaluateExpressionMode() ? this.storeByNameViaDebugger(node, string_id)
-                                : this.add(node, tryStoreGlobalByName(string_id));
+    tryStoreGlobalByName(node: ts.Node, string_id: string): void {
+        CmdOptions.isWatchEvaluateExpressionMode() ? this.storeByNameViaDebugger(node, string_id) :
+                                                     this.add(node, tryStoreGlobalByName(string_id));
     }
 
     // eg. var n; n;
-    loadGlobalVar(node: ts.Node, string_id: string) {
+    loadGlobalVar(node: ts.Node, string_id: string): void {
         this.add(
             node,
             loadGlobalVar(string_id));
     }
 
     // var n = 1;
-    storeGlobalVar(node: ts.Node | NodeKind, string_id: string) {
+    storeGlobalVar(node: ts.Node | NodeKind, string_id: string): void {
         this.add(
             node,
             storeGlobalVar(string_id));
     }
 
-    loadAccumulatorString(node: ts.Node | NodeKind, str: string) {
+    loadAccumulatorString(node: ts.Node | NodeKind, str: string): void {
         this.add(node, loadAccumulatorString(str));
     }
 
-    loadAccumulatorFloat(node: ts.Node, num: number) {
+    loadAccumulatorFloat(node: ts.Node, num: number): void {
         this.add(node, loadAccumulatorFloat(num));
     }
 
-    loadAccumulatorInt(node: ts.Node, num: number) {
+    loadAccumulatorInt(node: ts.Node, num: number): void {
         this.add(node, loadAccumulatorInt(num));
     }
 
-    moveVreg(node: ts.Node | NodeKind, vd: VReg, vs: VReg) {
+    moveVreg(node: ts.Node | NodeKind, vd: VReg, vs: VReg): void {
         this.add(node, moveVreg(vd, vs));
     }
 
     // @ts-ignore
-    label(node: ts.Node, label: Label) {
-        this.add(NodeKind.Invalid, label);
+    label(node: ts.Node, label: Label): void {
+        this.add(NodeKind.INVALID, label);
     }
 
-    branch(node: ts.Node | NodeKind, target: Label) {
+    branch(node: ts.Node | NodeKind, target: Label): void {
         this.add(node, jumpTarget(target));
     }
 
-    branchIfNotUndefined(node: ts.Node, target: Label) {
+    branchIfNotUndefined(node: ts.Node, target: Label): void {
         // the compared value is in acc
-        this.condition(node, ts.SyntaxKind.EqualsEqualsToken, getVregisterCache(this, CacheList.undefined), target);
+        this.condition(node, ts.SyntaxKind.EqualsEqualsToken, getVregisterCache(this, CacheList.UNDEFINED), target);
     }
 
-    branchIfUndefined(node: ts.Node, target: Label) {
+    branchIfUndefined(node: ts.Node, target: Label): void {
         // the compared value is in acc
-        this.condition(node, ts.SyntaxKind.ExclamationEqualsToken, getVregisterCache(this, CacheList.undefined), target)
+        this.condition(node, ts.SyntaxKind.ExclamationEqualsToken, getVregisterCache(this, CacheList.UNDEFINED), target)
     }
 
-    isTrue(node: ts.Node) {
+    isTrue(node: ts.Node): void {
         this.add(
             node,
             isTrue()
         )
     }
 
-    jumpIfTrue(node: ts.Node, target: Label) {
+    jumpIfTrue(node: ts.Node, target: Label): void {
         this.isFalse(node);
         this.add(
             node,
@@ -840,14 +840,14 @@ export class PandaGen {
         )
     }
 
-    isFalse(node: ts.Node) {
+    isFalse(node: ts.Node): void {
         this.add(
             node,
             isFalse()
         )
     }
 
-    jumpIfFalse(node: ts.Node, target: Label) {
+    jumpIfFalse(node: ts.Node, target: Label): void {
         this.isTrue(node);
         this.add(
             node,
@@ -855,46 +855,46 @@ export class PandaGen {
         )
     }
 
-    debugger(node: ts.Node) {
+    debugger(node: ts.Node): void {
         this.add(node, creatDebugger());
     }
 
-    throwUndefinedIfHole(node: ts.Node, name: string) {
+    throwUndefinedIfHole(node: ts.Node, name: string): void {
         this.add(
             node,
             throwUndefinedIfHole(name)
         )
     }
 
-    less(node: ts.Node, lhs: VReg) {
+    less(node: ts.Node, lhs: VReg): void {
         this.add(node, new Less(new Imm(0), lhs));
     }
 
-    greater(node: ts.Node, lhs: VReg) {
+    greater(node: ts.Node, lhs: VReg): void {
         this.add(node, new Greater(new Imm(0), lhs));
     }
 
-    greaterEq(node: ts.Node, lhs: VReg) {
+    greaterEq(node: ts.Node, lhs: VReg): void {
         this.add(node, new Greatereq(new Imm(0), lhs));
     }
 
-    lessEq(node: ts.Node, lhs: VReg) {
+    lessEq(node: ts.Node, lhs: VReg): void {
         this.add(node, new Lesseq(new Imm(0), lhs));
     }
 
-    equal(node: ts.Node, lhs: VReg) {
+    equal(node: ts.Node, lhs: VReg): void {
         this.add(node, new Eq(new Imm(0), lhs));
     }
 
-    notEqual(node: ts.Node, lhs: VReg) {
+    notEqual(node: ts.Node, lhs: VReg): void {
         this.add(node, new Noteq(new Imm(0), lhs));
     }
 
-    strictEqual(node: ts.Node, lhs: VReg) {
+    strictEqual(node: ts.Node, lhs: VReg): void {
         this.add(node, new Stricteq(new Imm(0), lhs));
     }
 
-    strictNotEqual(node: ts.Node, lhs: VReg) {
+    strictNotEqual(node: ts.Node, lhs: VReg): void {
         this.add(node, new Strictnoteq(new Imm(0), lhs));
     }
 
@@ -903,7 +903,7 @@ export class PandaGen {
      *          if (lhs OP acc) {...}
      * ifFalse: ...
      */
-    condition(node: ts.Node, op: SyntaxKind, lhs: VReg, ifFalse: Label) {
+    condition(node: ts.Node, op: SyntaxKind, lhs: VReg, ifFalse: Label): void {
         // Please keep order of cases the same as in types.ts
         switch (op) {
             case SyntaxKind.LessThanToken: // line 57
@@ -943,7 +943,7 @@ export class PandaGen {
         }
     }
 
-    unary(node: ts.Node, op: PrefixUnaryOperator, operand: VReg) {
+    unary(node: ts.Node, op: PrefixUnaryOperator, operand: VReg): void {
         switch (op) {
             case SyntaxKind.PlusToken:
                 this.toNumber(node, operand);
@@ -971,11 +971,11 @@ export class PandaGen {
                 let endLabel = new Label();
                 this.jumpIfFalse(node, falseLabel);
                 // operand is true
-                this.add(node, loadAccumulator(getVregisterCache(this, CacheList.False)));
+                this.add(node, loadAccumulator(getVregisterCache(this, CacheList.FALSE)));
                 this.branch(node, endLabel);
                 // operand is false
                 this.label(node, falseLabel);
-                this.add(node, loadAccumulator(getVregisterCache(this, CacheList.True)));
+                this.add(node, loadAccumulator(getVregisterCache(this, CacheList.TRUE)));
                 this.label(node, endLabel);
                 break;
             case SyntaxKind.TildeToken:
@@ -989,7 +989,7 @@ export class PandaGen {
         }
     }
 
-    binary(node: ts.Node, op: BinaryOperator, lhs: VReg) {
+    binary(node: ts.Node, op: BinaryOperator, lhs: VReg): void {
         switch (op) {
             case SyntaxKind.LessThanToken: // line 57
             case SyntaxKind.GreaterThanToken: // line 59
@@ -1066,30 +1066,30 @@ export class PandaGen {
 
     // throw needs argument of exceptionVreg
     // to ensure rethrow the exception after finally
-    throw(node: ts.Node) {
+    throw(node: ts.Node): void {
         this.add(
             node,
             throwException()
         );
     }
 
-    throwThrowNotExist(node: ts.Node) {
+    throwThrowNotExist(node: ts.Node): void {
         this.add(node, throwThrowNotExists());
     }
 
-    throwDeleteSuperProperty(node: ts.Node) {
+    throwDeleteSuperProperty(node: ts.Node): void {
         this.add(node, throwDeleteSuperProperty());
     }
 
-    throwConstAssignment(node: ts.Node, nameReg: VReg) {
+    throwConstAssignment(node: ts.Node, nameReg: VReg): void {
         this.add(node, throwConstAssignment(nameReg));
     }
 
-    return(node: ts.Node | NodeKind) {
+    return(node: ts.Node | NodeKind): void {
         this.add(node, new Return());
     }
 
-    call(node: ts.Node, args: VReg[], passThis: boolean) {
+    call(node: ts.Node, args: VReg[], passThis: boolean): void {
         this.add(
             node,
             loadAccumulator(args[0]), // callee is stored in acc
@@ -1097,21 +1097,21 @@ export class PandaGen {
         )
     }
 
-    returnUndefined(node: ts.Node | NodeKind) {
+    returnUndefined(node: ts.Node | NodeKind): void {
         this.add(
             node,
             returnUndefined()
         )
     }
 
-    newObject(node: ts.Node, args: VReg[]) {
+    newObject(node: ts.Node, args: VReg[]): void {
         this.add(
             node,
             newObject(args)
         );
     }
 
-    defineMethod(node: ts.FunctionLikeDeclaration, name: string, objReg: VReg) {
+    defineMethod(node: ts.FunctionLikeDeclaration, name: string, objReg: VReg): void {
         let paramLength = getParamLengthOfFunc(node);
         this.add(
             node,
@@ -1120,7 +1120,7 @@ export class PandaGen {
         );
     }
 
-    defineFunction(node: ts.FunctionLikeDeclaration | NodeKind, realNode: ts.FunctionLikeDeclaration, name: string) {
+    defineFunction(node: ts.FunctionLikeDeclaration | NodeKind, realNode: ts.FunctionLikeDeclaration, name: string): void {
         let paramLength = getParamLengthOfFunc(realNode);
         this.add(
             node,
@@ -1128,146 +1128,146 @@ export class PandaGen {
         );
     }
 
-    typeOf(node: ts.Node) {
+    typeOf(node: ts.Node): void {
         this.add(node, new Typeof(new Imm(0)));
     }
 
-    callSpread(node: ts.Node, func: VReg, thisReg: VReg, args: VReg) {
+    callSpread(node: ts.Node, func: VReg, thisReg: VReg, args: VReg): void {
         this.loadAccumulator(node, func);
         this.add(node, new Apply(new Imm(0), thisReg, args));
     }
 
-    newObjSpread(node: ts.Node, obj: VReg) {
+    newObjSpread(node: ts.Node, obj: VReg): void {
         this.add(node, new Newobjapply(new Imm(0), obj));
     }
 
-    getUnmappedArgs(node: ts.Node) {
+    getUnmappedArgs(node: ts.Node): void {
         this.add(node, new Getunmappedargs());
     }
 
-    toNumber(node: ts.Node, arg: VReg) {
+    toNumber(node: ts.Node, arg: VReg): void {
         this.loadAccumulator(node, arg);
         this.add(node, new Tonumber(new Imm(0)));
     }
 
-    toNumeric(node: ts.Node, arg: VReg) {
+    toNumeric(node: ts.Node, arg: VReg): void {
         this.loadAccumulator(node, arg);
         this.add(node, new Tonumeric(new Imm(0)));
     }
 
-    createGeneratorObj(node: ts.Node, funcObj: VReg) {
+    createGeneratorObj(node: ts.Node, funcObj: VReg): void {
         this.add(node, new Creategeneratorobj(funcObj));
     }
 
-    createAsyncGeneratorObj(node: ts.Node, funcObj: VReg) {
+    createAsyncGeneratorObj(node: ts.Node, funcObj: VReg): void {
         this.add(node, new Createasyncgeneratorobj(funcObj));
     }
 
-    Createiterresultobj(node: ts.Node, value: VReg, done: VReg) {
+    Createiterresultobj(node: ts.Node, value: VReg, done: VReg): void {
         this.add(node, new Createiterresultobj(value, done));
     }
 
-    asyncgeneratorresolve(node: ts.Node | NodeKind, genObj: VReg, value: VReg, done: VReg) {
+    asyncgeneratorresolve(node: ts.Node | NodeKind, genObj: VReg, value: VReg, done: VReg): void {
         this.add(node, new Asyncgeneratorresolve(genObj, value, done));
     }
 
-    asyncgeneratorreject(node: ts.Node, genObj: VReg) {
+    asyncgeneratorreject(node: ts.Node, genObj: VReg): void {
         this.add(node, new Asyncgeneratorreject(genObj));
     }
 
-    suspendGenerator(node: ts.Node | NodeKind, genObj: VReg) {
+    suspendGenerator(node: ts.Node | NodeKind, genObj: VReg): void {
         this.add(node, new Suspendgenerator(genObj)); // promise obj is in acc
     }
 
-    resumeGenerator(node: ts.Node | NodeKind, genObj: VReg) {
+    resumeGenerator(node: ts.Node | NodeKind, genObj: VReg): void {
         this.add(
             node,
             loadAccumulator(genObj),
             new Resumegenerator());
     }
 
-    getResumeMode(node: ts.Node | NodeKind, genObj: VReg) {
+    getResumeMode(node: ts.Node | NodeKind, genObj: VReg): void {
         this.add(
             node,
             loadAccumulator(genObj),
             new Getresumemode());
     }
 
-    asyncFunctionEnter(node: ts.Node | NodeKind) {
+    asyncFunctionEnter(node: ts.Node | NodeKind): void {
         this.add(node, new Asyncfunctionenter());
     }
 
-    asyncFunctionAwaitUncaught(node: ts.Node | NodeKind, asynFuncObj: VReg) {
+    asyncFunctionAwaitUncaught(node: ts.Node | NodeKind, asynFuncObj: VReg): void {
         this.add(node, new Asyncfunctionawaituncaught(asynFuncObj)); // received value is in acc
     }
 
-    asyncFunctionResolve(node: ts.Node | NodeKind, asyncObj: VReg) {
+    asyncFunctionResolve(node: ts.Node | NodeKind, asyncObj: VReg): void {
         this.add(node, new Asyncfunctionresolve(asyncObj)); // use retVal in acc
     }
 
-    asyncFunctionReject(node: ts.Node | NodeKind, asyncObj: VReg) {
+    asyncFunctionReject(node: ts.Node | NodeKind, asyncObj: VReg): void {
         this.add(node, new Asyncfunctionreject(asyncObj)); // exception is in acc
     }
 
-    getTemplateObject(node: ts.Node | NodeKind, value: VReg) {
+    getTemplateObject(node: ts.Node | NodeKind, value: VReg): void {
         this.loadAccumulator(node, value);
         this.add(node, new Gettemplateobject(new Imm(0)));
     }
 
-    copyRestArgs(node: ts.Node, index: number) {
+    copyRestArgs(node: ts.Node, index: number): void {
         this.add(node, 
                  index <= MAX_INT8 ? new Copyrestargs(new Imm(index)) : new WideCopyrestargs(new Imm(index)));
     }
 
-    getPropIterator(node: ts.Node) {
+    getPropIterator(node: ts.Node): void {
         this.add(node, getPropIterator());
     }
 
-    getNextPropName(node: ts.Node, iter: VReg) {
+    getNextPropName(node: ts.Node, iter: VReg): void {
         this.add(node, getNextPropName(iter));
     }
 
-    createEmptyObject(node: ts.Node) {
+    createEmptyObject(node: ts.Node): void {
         this.add(node, createEmptyObject());
     }
 
-    createObjectWithBuffer(node: ts.Node, bufferId: string) {
+    createObjectWithBuffer(node: ts.Node, bufferId: string): void {
         this.add(node, createObjectWithBuffer(bufferId));
     }
 
-    setObjectWithProto(node: ts.Node, proto: VReg, object: VReg) {
+    setObjectWithProto(node: ts.Node, proto: VReg, object: VReg): void {
         this.add(
             node,
             loadAccumulator(object),
             setObjectWithProto(proto));
     }
 
-    copyDataProperties(node: ts.Node, dstObj: VReg) {
+    copyDataProperties(node: ts.Node, dstObj: VReg): void {
         this.add(node, copyDataProperties(dstObj));
     }
 
-    defineGetterSetterByValue(node: ts.Node, obj: VReg, name: VReg, getter: VReg, setter: VReg, isComputedPropertyName: boolean) {
+    defineGetterSetterByValue(node: ts.Node, obj: VReg, name: VReg, getter: VReg, setter: VReg, isComputedPropertyName: boolean): void {
         if (isComputedPropertyName) {
-            this.add(node, loadAccumulator(getVregisterCache(this, CacheList.True)));
+            this.add(node, loadAccumulator(getVregisterCache(this, CacheList.TRUE)));
         } else {
-            this.add(node, loadAccumulator(getVregisterCache(this, CacheList.False)));
+            this.add(node, loadAccumulator(getVregisterCache(this, CacheList.FALSE)));
         }
         this.add(node, defineGetterSetterByValue(obj, name, getter, setter));
     }
 
-    createEmptyArray(node: ts.Node) {
+    createEmptyArray(node: ts.Node): void {
         this.add(node, createEmptyArray());
     }
 
-    createArrayWithBuffer(node: ts.Node, bufferId: string) {
+    createArrayWithBuffer(node: ts.Node, bufferId: string): void {
         this.add(node, createArrayWithBuffer(bufferId));
     }
 
-    storeArraySpreadElement(node: ts.Node, array: VReg, index: VReg) {
+    storeArraySpreadElement(node: ts.Node, array: VReg, index: VReg): void {
         this.add(node, storeArraySpread(array, index));
     }
 
-    storeLexicalVar(node: ts.Node, level: number, slot: number, value: VReg) {
+    storeLexicalVar(node: ts.Node, level: number, slot: number, value: VReg): void {
         this.loadAccumulator(node, value); // value is load to acc
         this.add(
             node,
@@ -1275,14 +1275,14 @@ export class PandaGen {
         );
     }
 
-    loadLexicalVar(node: ts.Node, level: number, slot: number) {
+    loadLexicalVar(node: ts.Node, level: number, slot: number): void {
         this.add(
             node,
             loadLexicalVar(level, slot)
         )
     }
 
-    loadModuleVariable(node: ts.Node, v: ModuleVariable, isLocal: boolean) {
+    loadModuleVariable(node: ts.Node, v: ModuleVariable, isLocal: boolean): void {
         let index: number = v.getIndex();
         let typeIndex: number = v.getTypeIndex();
         // For local module variable, we bind type with storeModuleVariable instruction
@@ -1298,7 +1298,7 @@ export class PandaGen {
         }
     }
 
-    storeModuleVariable(node: ts.Node | NodeKind, v: ModuleVariable) {
+    storeModuleVariable(node: ts.Node | NodeKind, v: ModuleVariable): void {
         let index: number = v.getIndex();
         let typeIndex: number = v.getTypeIndex();
         let stModuleVarInst: IRNode = storeModuleVariable(index);
@@ -1306,64 +1306,64 @@ export class PandaGen {
         this.add(node, stModuleVarInst);
     }
 
-    getModuleNamespace(node: ts.Node, moduleRequestIdx: number) {
+    getModuleNamespace(node: ts.Node, moduleRequestIdx: number): void {
         this.add(node, getModuleNamespace(moduleRequestIdx));
     }
 
-    dynamicImportCall(node: ts.Node) {
+    dynamicImportCall(node: ts.Node): void {
         this.add(node, dynamicImport());
     }
 
-    defineClassWithBuffer(node: ts.Node, name: string, litId: string, parameterLength: number, base: VReg) {
+    defineClassWithBuffer(node: ts.Node, name: string, litId: string, parameterLength: number, base: VReg): void {
         this.add(
             node,
             defineClassWithBuffer(name, litId, parameterLength, base)
         )
     }
 
-    createObjectWithExcludedKeys(node: ts.Node, obj: VReg, args: VReg[]) {
+    createObjectWithExcludedKeys(node: ts.Node, obj: VReg, args: VReg[]): void {
         this.add(
             node,
             createObjectWithExcludedKeys(obj, args)
         );
     }
 
-    throwObjectNonCoercible(node: ts.Node) {
+    throwObjectNonCoercible(node: ts.Node): void {
         this.add(
             node,
             throwObjectNonCoercible()
         );
     }
 
-    getIterator(node: ts.Node) {
+    getIterator(node: ts.Node): void {
         this.add(
             node,
             getIterator()
         );
     }
 
-    getAsyncIterator(node: ts.Node) {
+    getAsyncIterator(node: ts.Node): void {
         this.add(
             node,
             new Getasynciterator(new Imm(0))
         )
     }
 
-    closeIterator(node: ts.Node, iter: VReg) {
+    closeIterator(node: ts.Node, iter: VReg): void {
         this.add(
             node,
             closeIterator(iter)
         )
     }
 
-    throwIfNotObject(node: ts.Node, obj: VReg) {
+    throwIfNotObject(node: ts.Node, obj: VReg): void {
         this.add(
             node,
             throwIfNotObject(obj)
         );
     }
 
-    superCall(node: ts.Node, num: number, args: Array<VReg>) {
+    superCall(node: ts.Node, num: number, args: Array<VReg>): void {
         if (ts.isArrowFunction(jshelpers.getContainingFunction(node))) {
             this.add(
                 node,
@@ -1378,11 +1378,11 @@ export class PandaGen {
         )
     }
 
-    superCallSpread(node: ts.Node, vs: VReg) {
+    superCallSpread(node: ts.Node, vs: VReg): void {
         this.add(node, superCallSpread(vs));
     }
 
-    ldSuperByName(node: ts.Node, obj: VReg, key: string) {
+    ldSuperByName(node: ts.Node, obj: VReg, key: string): void {
         this.add(
             node,
             loadAccumulator(obj),
@@ -1390,28 +1390,28 @@ export class PandaGen {
         )
     }
 
-    stSuperByName(node: ts.Node, obj: VReg, key: string) {
+    stSuperByName(node: ts.Node, obj: VReg, key: string): void {
         this.add(
             node,
             stSuperByName(obj, key)
         )
     }
 
-    ldSuperByValue(node: ts.Node, obj: VReg) {
+    ldSuperByValue(node: ts.Node, obj: VReg): void {
         this.add(
             node,
             ldSuperByValue(obj)
         )
     }
 
-    stSuperByValue(node: ts.Node, obj: VReg, prop: VReg) {
+    stSuperByValue(node: ts.Node, obj: VReg, prop: VReg): void {
         this.add(
             node,
             stSuperByValue(obj, prop)
         )
     }
 
-    loadSuperProperty(node: ts.Node, obj: VReg, prop: VReg | string | number) {
+    loadSuperProperty(node: ts.Node, obj: VReg, prop: VReg | string | number): void {
         switch (typeof (prop)) {
             case "string":
                 this.ldSuperByName(node, obj, prop);
@@ -1426,11 +1426,11 @@ export class PandaGen {
         }
     }
 
-    throwIfSuperNotCorrectCall(node: ts.Node, num: number) {
+    throwIfSuperNotCorrectCall(node: ts.Node, num: number): void {
         this.add(node, throwIfSuperNotCorrectCall(num));
     }
 
-    storeSuperProperty(node: ts.Node, obj: VReg, prop: VReg | string | number) {
+    storeSuperProperty(node: ts.Node, obj: VReg, prop: VReg | string | number): void {
         switch (typeof (prop)) {
             case "string":
                 this.stSuperByName(node, obj, prop);
@@ -1440,44 +1440,44 @@ export class PandaGen {
                 this.loadAccumulatorInt(node, prop);
                 this.storeAccumulator(node, propReg);
                 this.stSuperByValue(node, obj, propReg);
-                this.freeTemps(propReg)
+                this.freeTemps(propReg);
                 break;
             default:
                 this.stSuperByValue(node, obj, prop);
         }
     }
 
-    createRegExpWithLiteral(node: ts.Node, pattern: string, flags: number) {
+    createRegExpWithLiteral(node: ts.Node, pattern: string, flags: number): void {
         this.add(
             node,
             createRegExpWithLiteral(pattern, flags)
         )
     }
 
-    stLetOrClassToGlobalRecord(node: ts.Node, string_id: string) {
+    stLetOrClassToGlobalRecord(node: ts.Node, string_id: string): void {
         this.add(
             node,
             stLetOrClassToGlobalRecord(string_id));
     }
 
-    stConstToGlobalRecord(node: ts.Node, string_id: string) {
+    stConstToGlobalRecord(node: ts.Node, string_id: string): void {
         this.add(
             node,
             stConstToGlobalRecord(string_id));
     }
 
-    loadAccumulatorBigInt(node: ts.Node | NodeKind, str: string) {
+    loadAccumulatorBigInt(node: ts.Node | NodeKind, str: string): void {
         this.add(
             node,
             loadAccumulatorBigInt(str));
     }
 
-    storeConst(node: ts.Node | NodeKind, dst: VReg, value: CacheList) {
+    storeConst(node: ts.Node | NodeKind, dst: VReg, value: CacheList): void {
         this.loadAccumulator(node, getVregisterCache(this, value));
         this.storeAccumulator(node, dst);
     }
 
-    private binaryRelation(node: ts.Node, op: BinaryOperator, lhs: VReg) {
+    private binaryRelation(node: ts.Node, op: BinaryOperator, lhs: VReg): void {
         let falseLabel = new Label();
         let endLabel = new Label();
         switch (op) {
@@ -1509,10 +1509,10 @@ export class PandaGen {
                 break;
         }
         this.add(node, new Jeqz(falseLabel));
-        this.add(node, loadAccumulator(getVregisterCache(this, CacheList.True)));
+        this.add(node, loadAccumulator(getVregisterCache(this, CacheList.TRUE)));
         this.branch(node, endLabel);
         this.label(node, falseLabel);
-        this.add(node, loadAccumulator(getVregisterCache(this, CacheList.False)));
+        this.add(node, loadAccumulator(getVregisterCache(this, CacheList.FALSE)));
         this.label(node, endLabel);
     }
 
diff --git a/ts2panda/src/recorder.ts b/ts2panda/src/recorder.ts
index eea7f7f0fa..f820f7e47d 100644
--- a/ts2panda/src/recorder.ts
+++ b/ts2panda/src/recorder.ts
@@ -82,26 +82,26 @@ export class Recorder {
         this.syntaxCheckStatus = syntaxCheckStatus;
     }
 
-    record() {
+    record(): ts.Node {
         this.setParent(this.node);
         this.setScopeMap(this.node, this.scope);
         this.recordInfo(this.node, this.scope);
         return this.node;
     }
 
-    getCtorOfClass(node: ts.ClassLikeDeclaration) {
+    getCtorOfClass(node: ts.ClassLikeDeclaration): ts.ConstructorDeclaration {
         return this.class2Ctor.get(node);
     }
 
-    setCtorOfClass(node: ts.ClassLikeDeclaration, ctor: ts.ConstructorDeclaration) {
+    setCtorOfClass(node: ts.ClassLikeDeclaration, ctor: ts.ConstructorDeclaration): void {
         if (!this.class2Ctor.has(node)) {
             this.class2Ctor.set(node, ctor);
         }
     }
 
-    private setParent(node: ts.Node) {
+    private setParent(node: ts.Node): void {
         node.forEachChild(childNode => {
-            if (!this.isTsFile || childNode!.parent == undefined || childNode.parent.kind != node.kind) {
+            if (!this.isTsFile || childNode!.parent === undefined || childNode.parent.kind != node.kind) {
                 childNode = jshelpers.setParent(childNode, node)!;
                 let originNode = ts.getOriginalNode(childNode);
                 childNode = ts.setTextRange(childNode, originNode);
@@ -110,7 +110,7 @@ export class Recorder {
         });
     }
 
-    private recordInfo(node: ts.Node, scope: Scope) {
+    private recordInfo(node: ts.Node, scope: Scope): void {
         node.forEachChild(childNode => {
             if (this.syntaxCheckStatus) {
                 checkSyntaxError(childNode, scope);
@@ -132,7 +132,8 @@ export class Recorder {
                     let isExport: boolean = false;
                     if (hasExportKeywordModifier(childNode)) {
                         if (!CmdOptions.isModules()) {
-                            throw new DiagnosticError(childNode, DiagnosticCode.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none, jshelpers.getSourceFileOfNode(childNode));
+                            throw new DiagnosticError(childNode, DiagnosticCode.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none,
+                                                      jshelpers.getSourceFileOfNode(childNode));
                         }
                         this.recordEcmaExportInfo(<ts.FunctionDeclaration>childNode, scope);
                         isExport = true;
@@ -172,7 +173,8 @@ export class Recorder {
                     let isExport: boolean = false;
                     if (hasExportKeywordModifier(childNode)) {
                         if (!CmdOptions.isModules()) {
-                            throw new DiagnosticError(childNode, DiagnosticCode.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none, jshelpers.getSourceFileOfNode(childNode));
+                            throw new DiagnosticError(childNode, DiagnosticCode.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none,
+                                                      jshelpers.getSourceFileOfNode(childNode));
                         }
                         this.recordEcmaExportInfo(<ts.ClassDeclaration>childNode, scope);
                         isExport = true;
@@ -202,7 +204,8 @@ export class Recorder {
                 }
                 case ts.SyntaxKind.ImportDeclaration: {
                     if (!CmdOptions.isModules()) {
-                        throw new DiagnosticError(childNode, DiagnosticCode.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none, jshelpers.getSourceFileOfNode(childNode));
+                        throw new DiagnosticError(childNode, DiagnosticCode.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none,
+                                                  jshelpers.getSourceFileOfNode(childNode));
                     }
                     this.recordEcmaImportInfo(<ts.ImportDeclaration>childNode, scope);
 
@@ -255,7 +258,7 @@ export class Recorder {
         });
     }
 
-    private recordClassInfo(childNode: ts.ClassLikeDeclaration, scope: Scope, isExport: boolean) {
+    private recordClassInfo(childNode: ts.ClassLikeDeclaration, scope: Scope, isExport: boolean): void {
         let localScope = new LocalScope(scope);
         this.setScopeMap(childNode, localScope);
         let ctor = extractCtorOfClass(childNode);
@@ -273,7 +276,7 @@ export class Recorder {
         this.recordInfo(childNode, localScope);
     }
 
-    buildVariableScope(curScope: Scope, node: ts.FunctionLikeDeclaration) {
+    buildVariableScope(curScope: Scope, node: ts.FunctionLikeDeclaration): FunctionScope {
         let functionScope = new FunctionScope(curScope, <ts.FunctionLikeDeclaration>node);
         let parentVariableScope = <VariableScope>curScope.getNearestVariableScope();
         functionScope.setParentVariableScope(parentVariableScope);
@@ -282,20 +285,20 @@ export class Recorder {
         return functionScope;
     }
 
-    private recordVariableDecl(id: ts.Identifier, scope: Scope) {
+    private recordVariableDecl(id: ts.Identifier, scope: Scope): void {
         let name = jshelpers.getTextOfIdentifierOrLiteral(id);
         let parent = this.getDeclarationNodeOfId(id);
 
         if (parent) {
             let declKind = astutils.getVarDeclarationKind(<ts.VariableDeclaration>parent);
             let isExportDecl: boolean = false;
-            if ((<ts.VariableDeclaration>parent).parent.parent.kind == ts.SyntaxKind.VariableStatement) {
+            if ((<ts.VariableDeclaration>parent).parent.parent.kind === ts.SyntaxKind.VariableStatement) {
                 isExportDecl = hasExportKeywordModifier((<ts.VariableDeclaration>parent).parent.parent);
             }
 
             // collect declaration information to corresponding scope
             let decl = this.addVariableDeclToScope(scope, id, parent, name, declKind, isExportDecl);
-            if (declKind == VarDeclarationKind.VAR) {
+            if (declKind === VarDeclarationKind.VAR) {
                 let variableScopeParent = <VariableScope>scope.getNearestVariableScope();
                 this.collectHoistDecls(id, variableScopeParent, decl);
             }
@@ -312,7 +315,7 @@ export class Recorder {
                     let needCreateLoopEnv: boolean = false;
                     if (nearestDefLexicalScope instanceof LoopScope) {
                         while (tmp) {
-                            if (tmp == nearestDefLexicalScope) {
+                            if (tmp === nearestDefLexicalScope) {
                                 needCreateLoopEnv = true;
                                 break;
                             }
@@ -328,7 +331,7 @@ export class Recorder {
             }
         }
 
-        if (name == MandatoryArguments) {
+        if (name === MandatoryArguments) {
             let varialbeScope = scope.getNearestVariableScope();
             varialbeScope?.setUseArgs(true);
         }
@@ -342,7 +345,7 @@ export class Recorder {
             case VarDeclarationKind.VAR:
                 break;
             case VarDeclarationKind.LET:
-                    if (parent.parent.kind == ts.SyntaxKind.CatchClause) {
+                    if (parent.parent.kind === ts.SyntaxKind.CatchClause) {
                     decl = new CatchParameter(name, node);
                 } else {
                     decl = new LetDecl(name, node, moduleKind);
@@ -361,10 +364,10 @@ export class Recorder {
     private getDeclarationNodeOfId(id: ts.Identifier): ts.VariableDeclaration | undefined {
         let parent = id.parent;
         if (ts.isVariableDeclaration(parent) &&
-            parent.name == id) {
+            parent.name === id) {
             return <ts.VariableDeclaration>parent;
         } else if (ts.isBindingElement(parent) &&
-            parent.name == id) {
+            parent.name === id) {
             while (parent && !ts.isVariableDeclaration(parent)) {
                 parent = parent.parent;
             }
@@ -471,7 +474,7 @@ export class Recorder {
             scope.setDecls(new ConstDecl(nameSpace, namedBindings, ModuleVarKind.NOT));
             scope.module().addStarImportEntry(namedBindings, nameSpace, moduleRequest);
         } else if (ts.isNamedImports(namedBindings)) {
-            if (namedBindings.elements.length == 0) {
+            if (namedBindings.elements.length === 0) {
                 // import {} from "a.js"
                 scope.module().addEmptyImportEntry(moduleRequest);
             }
@@ -487,7 +490,7 @@ export class Recorder {
         }
     }
 
-    private recordEcmaImportClause(importClause: ts.ImportClause, scope: ModuleScope, moduleRequest: string) {
+    private recordEcmaImportClause(importClause: ts.ImportClause, scope: ModuleScope, moduleRequest: string): void {
         // import defaultExport from "a.js"
         if (importClause.name) {
             let localName = jshelpers.getTextOfIdentifierOrLiteral(importClause.name);
@@ -500,7 +503,7 @@ export class Recorder {
         }
     }
 
-    private recordEcmaImportInfo(node: ts.ImportDeclaration, scope: Scope) {
+    private recordEcmaImportInfo(node: ts.ImportDeclaration, scope: Scope): void {
         if (!(scope instanceof ModuleScope)) {
             return;
         }
@@ -516,7 +519,7 @@ export class Recorder {
         }
     }
 
-    private recordEcmaExportDecl(node: ts.ExportDeclaration, scope: ModuleScope) {
+    private recordEcmaExportDecl(node: ts.ExportDeclaration, scope: ModuleScope): void {
         if (node.moduleSpecifier) {
             let moduleRequest: string = this.getModuleSpecifier(node.moduleSpecifier);
 
@@ -526,7 +529,7 @@ export class Recorder {
                     // Targetcase 1: export * as m from "mod";
                     // Targetcase 2: `export namespace` is not the ECMA2018's feature
                 } else if (ts.isNamedExports(namedBindings)) {
-                    if (namedBindings.elements.length == 0) {
+                    if (namedBindings.elements.length === 0) {
                         // export {} from "mod";
                         scope.module().addEmptyImportEntry(moduleRequest);
                     }
@@ -555,7 +558,8 @@ export class Recorder {
         }
     }
 
-    private recordEcmaExportInfo(node: ts.ExportDeclaration | ts.ExportAssignment | ts.VariableStatement | ts.FunctionDeclaration | ts.ClassDeclaration, scope: Scope) {
+    private recordEcmaExportInfo(node: ts.ExportDeclaration | ts.ExportAssignment | ts.VariableStatement |
+                                 ts.FunctionDeclaration | ts.ClassDeclaration, scope: Scope): void {
         if (!(scope instanceof ModuleScope)) {
             return;
         }
@@ -606,7 +610,7 @@ export class Recorder {
         }
     }
 
-    private recordFuncDecl(node: ts.FunctionDeclaration, scope: Scope, isExport: boolean) {
+    private recordFuncDecl(node: ts.FunctionDeclaration, scope: Scope, isExport: boolean): void {
         this.recordFuncInfo(node);
 
         let funcId = <ts.Identifier>(node).name;
@@ -635,7 +639,7 @@ export class Recorder {
         }
     }
 
-    private recordOtherFunc(node: ts.FunctionLikeDeclaration, scope: Scope) { // functionlikedecalration except function declaration
+    private recordOtherFunc(node: ts.FunctionLikeDeclaration, scope: Scope): void { // functionlikedecalration except function declaration
         this.recordFuncInfo(node);
         if (!ts.isFunctionExpression(node) && !ts.isMethodDeclaration(node)) {
             return;
@@ -648,12 +652,12 @@ export class Recorder {
         }
     }
 
-    private recordFuncInfo(node: ts.FunctionLikeDeclaration) {
+    private recordFuncInfo(node: ts.FunctionLikeDeclaration): void {
         this.recordFunctionParameters(node);
         this.recordFuncName(node);
     }
 
-    recordFuncName(node: ts.FunctionLikeDeclaration) {
+    recordFuncName(node: ts.FunctionLikeDeclaration): void {
         let name: string = '';
         if (ts.isConstructorDeclaration(node)) {
             let classNode = node.parent;
@@ -670,7 +674,7 @@ export class Recorder {
                     }
                 } else if (ts.isBinaryExpression(outerNode)) {
                     // @ts-ignore
-                    if (outerNode.operatorToken.kind == ts.SyntaxKind.EqualsToken && ts.isIdentifier(outerNode.left)) {
+                    if (outerNode.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(outerNode.left)) {
                         // @ts-ignore
                         name = jshelpers.getTextOfIdentifierOrLiteral(outerNode.left);
                     }
@@ -679,7 +683,7 @@ export class Recorder {
                     let propName = outerNode.name;
                     if (ts.isIdentifier(propName) || ts.isStringLiteral(propName) || ts.isNumericLiteral(propName)) {
                         name = jshelpers.getTextOfIdentifierOrLiteral(propName);
-                        if (name == "__proto__") {
+                        if (name === "__proto__") {
                             name = '';
                         }
                     }
@@ -704,7 +708,7 @@ export class Recorder {
         }
     }
 
-    recordFunctionParameters(node: ts.FunctionLikeDeclaration) {
+    recordFunctionParameters(node: ts.FunctionLikeDeclaration): void {
         let parameters = node.parameters;
         let funcParams: FunctionParameter[] = [];
         let length = 0;
@@ -732,7 +736,7 @@ export class Recorder {
         this.setParametersMap(node, funcParams);
     }
 
-    recordPatternParameter(pattern: ts.BindingPattern, funcParams: Array<FunctionParameter>) {
+    recordPatternParameter(pattern: ts.BindingPattern, funcParams: Array<FunctionParameter>): void {
         let name: string = '';
         pattern.elements.forEach(bindingElement => {
             if (ts.isOmittedExpression(bindingElement)) {
@@ -751,7 +755,7 @@ export class Recorder {
     }
 
 
-    isRestParameter(parameter: ts.ParameterDeclaration) {
+    isRestParameter(parameter: ts.ParameterDeclaration): boolean {
         return parameter.dotDotDotToken ? true : false;
     }
 
@@ -764,7 +768,7 @@ export class Recorder {
             let functionParameters = this.getParametersOfFunction(<ts.FunctionLikeDeclaration>nearestFunc);
             if (functionParameters) {
                 for (let i = 0; i < functionParameters.length; i++) {
-                    if (functionParameters[i].name == declName) {
+                    if (functionParameters[i].name === declName) {
                         return false;
                     }
                 }
@@ -780,19 +784,19 @@ export class Recorder {
         return false;
     }
 
-    setScopeMap(node: ts.Node, scope: Scope) {
+    setScopeMap(node: ts.Node, scope: Scope): void {
         this.scopeMap.set(node, scope);
     }
 
-    getScopeMap() {
+    getScopeMap(): Map<ts.Node, Scope> {
         return this.scopeMap;
     }
 
-    getScopeOfNode(node: ts.Node) {
+    getScopeOfNode(node: ts.Node): Scope {
         return this.scopeMap.get(node);
     }
 
-    setHoistMap(scope: VariableScope, decl: Decl) {
+    setHoistMap(scope: VariableScope, decl: Decl): void {
         if (!this.hoistMap.has(scope)) {
             this.hoistMap.set(scope, [decl]);
             return;
@@ -800,7 +804,7 @@ export class Recorder {
 
         let hoistDecls = <Decl[]>this.hoistMap.get(scope);
         for (let i = 0; i < hoistDecls.length; i++) {
-            if (decl.name == hoistDecls[i].name) {
+            if (decl.name === hoistDecls[i].name) {
                 if (decl instanceof FuncDecl) {
                     hoistDecls[i] = decl;
                 }
@@ -810,23 +814,23 @@ export class Recorder {
         hoistDecls.push(decl);
     }
 
-    getHoistMap() {
+    getHoistMap(): Map<Scope, Decl[]> {
         return this.hoistMap;
     }
 
-    getHoistDeclsOfScope(scope: VariableScope) {
+    getHoistDeclsOfScope(scope: VariableScope): Decl[] {
         return this.hoistMap.get(scope);
     }
 
-    setParametersMap(node: ts.FunctionLikeDeclaration, parameters: FunctionParameter[]) {
+    setParametersMap(node: ts.FunctionLikeDeclaration, parameters: FunctionParameter[]): void {
         this.parametersMap.set(node, parameters);
     }
 
-    getParametersOfFunction(node: ts.FunctionLikeDeclaration) {
+    getParametersOfFunction(node: ts.FunctionLikeDeclaration): FunctionParameter[] {
         return this.parametersMap.get(node);
     }
 
-    getFuncNameMap() {
+    getFuncNameMap(): Map<string, number> {
         return this.funcNameMap;
     }
 }
diff --git a/ts2panda/src/regAllocator.ts b/ts2panda/src/regAllocator.ts
index 790745246c..2fdd0a5b74 100644
--- a/ts2panda/src/regAllocator.ts
+++ b/ts2panda/src/regAllocator.ts
@@ -41,7 +41,7 @@ class RegAllocator {
         this.vRegsId = 0;
     }
 
-    allocIndexForVreg(vreg: VReg) {
+    allocIndexForVreg(vreg: VReg): void {
         let num = this.getFreeVreg();
         vreg.num = num;
     }
@@ -77,7 +77,7 @@ class RegAllocator {
         return num;
     }
 
-    doRealAdjustment(operands: OperandType[], format: Format, index: number, irNodes: IRNode[]) {
+    doRealAdjustment(operands: OperandType[], format: Format, index: number, irNodes: IRNode[]): void {
         let head: IRNode[] = [];
         let tail: IRNode[] = [];
 
@@ -87,13 +87,13 @@ class RegAllocator {
                 if (vOrigin.num >= (1 << format[j][1])) {
                     let spill = this.getSpill();
                     operands[j] = spill;
-                    if (format[j][0] == OperandKind.SrcVReg) {
+                    if (format[j][0] === OperandKind.SrcVReg) {
                         head.push(new Mov(spill, vOrigin));
-                    } else if (format[j][0] == OperandKind.DstVReg) {
-                        tail.push(new Mov(vOrigin, spill))
-                    } else if (format[j][0] == OperandKind.SrcDstVReg) {
+                    } else if (format[j][0] === OperandKind.DstVReg) {
+                        tail.push(new Mov(vOrigin, spill));
+                    } else if (format[j][0] === OperandKind.SrcDstVReg) {
                         head.push(new Mov(spill, vOrigin));
-                        tail.push(new Mov(vOrigin, spill))
+                        tail.push(new Mov(vOrigin, spill));
                     } else {
                         // here we do nothing
                     }
@@ -135,7 +135,7 @@ class RegAllocator {
         }
 
         /* If the parameters are consecutive, no adjustment is required. */
-        if (i == (irNodes[index]).operands.length) {
+        if (i === (irNodes[index]).operands.length) {
             return true;
         }
 
@@ -143,7 +143,7 @@ class RegAllocator {
         return false;
     }
 
-    adjustDynRangeInstruction(irNodes: IRNode[], index: number) {
+    adjustDynRangeInstruction(irNodes: IRNode[], index: number): void {
         let head: IRNode[] = [];
         let operands = irNodes[index].operands;
 
diff --git a/ts2panda/src/scope.ts b/ts2panda/src/scope.ts
index 616d899360..0bcda2d4d4 100644
--- a/ts2panda/src/scope.ts
+++ b/ts2panda/src/scope.ts
@@ -77,14 +77,14 @@ export class ClassDecl extends Decl {
 }
 
 export class CatchParameter extends Decl {
-    constructor(CpName: string, node: ts.Node, isModule: ModuleVarKind = ModuleVarKind.NOT) {
-        super(CpName, node, isModule);
+    constructor(cpName: string, node: ts.Node, isModule: ModuleVarKind = ModuleVarKind.NOT) {
+        super(cpName, node, isModule);
     }
 }
 
 export class FunctionParameter extends Decl {
-    constructor(FpName: string, node: ts.Node, isModule: ModuleVarKind = ModuleVarKind.NOT) {
-        super(FpName, node, isModule);
+    constructor(fpName: string, node: ts.Node, isModule: ModuleVarKind = ModuleVarKind.NOT) {
+        super(fpName, node, isModule);
     }
 }
 
@@ -106,7 +106,7 @@ export abstract class Scope {
         return this.name2variable;
     }
 
-    getScopeStartInsIdx() {
+    getScopeStartInsIdx(): number {
         return this.startInsIdx;
     }
 
@@ -118,11 +118,11 @@ export abstract class Scope {
         this.endInsIdx = endInsIdx;
     }
 
-    getScopeEndInsIdx() {
+    getScopeEndInsIdx(): number {
         return this.endInsIdx;
     }
 
-    setParent(parentScope: Scope | undefined) {
+    setParent(parentScope: Scope | undefined): void {
         this.parent = parentScope;
     }
 
@@ -173,7 +173,7 @@ export abstract class Scope {
 
         while (sp) {
             if (sp instanceof VariableScope) {
-                if (tempLevel == 0) {
+                if (tempLevel === 0) {
                     return <VariableScope>sp;
                 } else {
                     tempLevel--;
@@ -234,7 +234,7 @@ export abstract class Scope {
         let enclosingVariableScope: VariableScope = this.getNearestVariableScope();
 
         while (curScope) {
-            if (curScope == enclosingVariableScope.parent) {
+            if (curScope === enclosingVariableScope.parent) {
                 crossFunc = true;
             }
 
@@ -254,14 +254,14 @@ export abstract class Scope {
         return {isLexical: false, scope: undefined, defLexicalScope: undefined, v: undefined};
     }
 
-    setDecls(decl: Decl) {
+    setDecls(decl: Decl): void {
         this.decls.push(decl);
     }
 
     hasDecl(name: string): boolean {
         let decls = this.decls;
         for (let i = 0; i < decls.length; i++) {
-            if (decls[i].name == name) {
+            if (decls[i].name === name) {
                 return true;
             }
         }
@@ -272,7 +272,7 @@ export abstract class Scope {
     getDecl(name: string): Decl | undefined {
         let decls = this.decls;
         for (let i = 0; i < decls.length; i++) {
-            if (decls[i].name == name) {
+            if (decls[i].name === name) {
                 return decls[i];
             }
         }
@@ -280,11 +280,11 @@ export abstract class Scope {
         return undefined;
     }
 
-    getDecls() {
+    getDecls(): Decl[] {
         return this.decls;
     }
 
-    public setArgumentsOrRestargs() {
+    public setArgumentsOrRestargs(): void {
         this.isArgumentsOrRestargs = true;
     }
 
@@ -292,7 +292,7 @@ export abstract class Scope {
         return this.isArgumentsOrRestargs;
     }
 
-    isLexicalScope() {
+    isLexicalScope(): boolean {
         let scope = this;
         return ((scope instanceof VariableScope) || (scope instanceof LoopScope));
     }
@@ -308,31 +308,31 @@ export abstract class VariableScope extends Scope {
     protected childVariableScope: VariableScope[] = [];
     protected lexVarInfo: Map<string, number> = new Map<string, number>();
 
-    getLexVarInfo() {
+    getLexVarInfo(): Map<string, number> {
         return this.lexVarInfo;
     }
 
-    addLexVarInfo(name: string, slot: number) {
+    addLexVarInfo(name: string, slot: number): void {
         this.lexVarInfo.set(name, slot);
     }
 
-    getBindingNode() {
+    getBindingNode(): ts.Node {
         return this.node;
     }
 
-    setParentVariableScope(scope: VariableScope) {
+    setParentVariableScope(scope: VariableScope): void {
         this.parentVariableScope = scope;
     }
 
-    getParentVariableScope() {
+    getParentVariableScope(): VariableScope {
         return this.parentVariableScope;
     }
 
-    getChildVariableScope() {
+    getChildVariableScope(): VariableScope[] {
         return this.childVariableScope;
     }
 
-    addChildVariableScope(scope: VariableScope) {
+    addChildVariableScope(scope: VariableScope): void {
         this.childVariableScope.push(scope);
     }
 
@@ -346,7 +346,7 @@ export abstract class VariableScope extends Scope {
         return v;
     }
 
-    addFuncName(funcName: string) {
+    addFuncName(funcName: string): void {
         let funcObj = this.name2variable.get(MandatoryFuncObj);
         this.name2variable.set(funcName, funcObj!);
     }
@@ -355,7 +355,7 @@ export abstract class VariableScope extends Scope {
         return this.needCreateLexEnv;
     }
 
-    pendingCreateEnv() {
+    pendingCreateEnv(): void {
         this.needCreateLexEnv = true;
     }
 
@@ -371,7 +371,7 @@ export abstract class VariableScope extends Scope {
         return this.parameters;
     }
 
-    getLexVarIdx() {
+    getLexVarIdx(): number {
         this.needCreateLexEnv = true;
         return this.startLexIdx++;
     }
@@ -406,7 +406,7 @@ export class GlobalScope extends VariableScope {
         let name = decl instanceof Decl ? decl.name : decl;
         LOGD(this.debugTag, "globalscope.add (" + name + "), kind:" + declKind);
         let v: Variable | undefined;
-        if (declKind == VarDeclarationKind.NONE || declKind == VarDeclarationKind.VAR || declKind == VarDeclarationKind.FUNCTION) {
+        if (declKind === VarDeclarationKind.NONE || declKind === VarDeclarationKind.VAR || declKind === VarDeclarationKind.FUNCTION) {
             v = new GlobalVariable(declKind, name);
         } else {
             v = new LocalVariable(declKind, name, status);
@@ -425,14 +425,14 @@ export class ModuleScope extends VariableScope {
         this.moduleRecord = new SourceTextModuleRecord(node.fileName);
     }
 
-    setExportDecl(exportedLocalName: string) {
+    setExportDecl(exportedLocalName: string): void {
         let decl = this.getDecl(exportedLocalName);
         if (decl && decl.isModule != ModuleVarKind.IMPORTED) {
             decl.isModule = ModuleVarKind.EXPORTED;
         }
     }
 
-    module() {
+    module(): SourceTextModuleRecord {
         return this.moduleRecord;
     }
 
@@ -443,13 +443,13 @@ export class ModuleScope extends VariableScope {
 
         if (isModule !== ModuleVarKind.NOT) {
             v = new ModuleVariable(declKind, name, InitStatus.UNINITIALIZED);
-            if (isModule == ModuleVarKind.EXPORTED) {
+            if (isModule === ModuleVarKind.EXPORTED) {
                 (<ModuleVariable>v).setExport();
             }
         } else {
             if (declKind === VarDeclarationKind.NONE) {
                 v = new GlobalVariable(declKind, name);
-            } else if (declKind == VarDeclarationKind.VAR || declKind == VarDeclarationKind.FUNCTION) {
+            } else if (declKind === VarDeclarationKind.VAR || declKind === VarDeclarationKind.FUNCTION) {
                 v = new LocalVariable(declKind, name);
             } else {
                 v = new LocalVariable(declKind, name, status);
@@ -470,7 +470,7 @@ export class FunctionScope extends VariableScope {
         this.node = node ? node : undefined;
     }
 
-    setParameterLength(length: number) {
+    setParameterLength(length: number): void {
         this.parameterLength = length;
     }
 
@@ -478,11 +478,11 @@ export class FunctionScope extends VariableScope {
         return this.parameterLength;
     }
 
-    setFuncName(name: string) {
+    setFuncName(name: string): void {
         this.funcName = name;
     }
 
-    getFuncName() {
+    getFuncName(): string {
         return this.funcName;
     }
 
@@ -495,12 +495,12 @@ export class FunctionScope extends VariableScope {
         let v: Variable | undefined;
         LOGD(this.debugTag, "functionscope.add (" + name + "), kind:" + declKind);
 
-        if (declKind == VarDeclarationKind.NONE) {
+        if (declKind === VarDeclarationKind.NONE) {
             // the variable declared without anything should be global
             // See EcmaStandard: 13.3.2 Variable Statement
             let topLevelScope = this.getRootScope();
             v = topLevelScope.add(name, declKind);
-        } else if (declKind == VarDeclarationKind.VAR || declKind == VarDeclarationKind.FUNCTION) {
+        } else if (declKind === VarDeclarationKind.VAR || declKind === VarDeclarationKind.FUNCTION) {
             v = new LocalVariable(declKind, name);
             this.name2variable.set(name, v);
         } else {
@@ -514,7 +514,7 @@ export class FunctionScope extends VariableScope {
 export class LocalScope extends Scope {
     constructor(parent: Scope) {
         super();
-        this.parent = parent
+        this.parent = parent;
     }
 
     add(decl: Decl | string, declKind: VarDeclarationKind, status?: InitStatus): Variable | undefined {
@@ -522,10 +522,10 @@ export class LocalScope extends Scope {
         let v: Variable | undefined;
 
         LOGD(this.debugTag, "localscope.add (" + name + "), kind:" + declKind);
-        if (declKind == VarDeclarationKind.NONE) {
+        if (declKind === VarDeclarationKind.NONE) {
             let topLevelScope = this.getRootScope();
             v = topLevelScope.add(name, declKind);
-        } else if (declKind == VarDeclarationKind.VAR) {
+        } else if (declKind === VarDeclarationKind.VAR) {
             /**
              * the variable declared without anything should be accessible
              * in all parent scopes so delegate creation to the parent
@@ -550,11 +550,11 @@ export class LoopScope extends LocalScope {
         super(parent);
     }
 
-    getLexVarInfo() {
+    getLexVarInfo(): Map<string, number> {
         return this.lexVarInfo;
     }
 
-    addLexVarInfo(name: string, slot: number) {
+    addLexVarInfo(name: string, slot: number): void {
         this.lexVarInfo.set(name, slot);
     }
 
@@ -562,11 +562,11 @@ export class LoopScope extends LocalScope {
         return this.needCreateLexEnv;
     }
 
-    pendingCreateEnv() {
+    pendingCreateEnv(): void {
         this.needCreateLexEnv = true;
     }
 
-    getLexVarIdx() {
+    getLexVarIdx(): number {
         this.needCreateLexEnv = true;
         return this.startLexIdx++;
     }
diff --git a/ts2panda/src/statement/classStatement.ts b/ts2panda/src/statement/classStatement.ts
index e455b1a3ae..b9a548b141 100644
--- a/ts2panda/src/statement/classStatement.ts
+++ b/ts2panda/src/statement/classStatement.ts
@@ -56,7 +56,7 @@ import {
     Variable
 } from "../variable";
 
-export function compileClassDeclaration(compiler: Compiler, stmt: ts.ClassLikeDeclaration) {
+export function compileClassDeclaration(compiler: Compiler, stmt: ts.ClassLikeDeclaration): void {
     compiler.pushScope(stmt);
 
     let pandaGen = compiler.getPandaGen();
@@ -71,12 +71,12 @@ export function compileClassDeclaration(compiler: Compiler, stmt: ts.ClassLikeDe
     let classBuffer = new LiteralBuffer();
     let propertyIndex = 0;
     let staticItemsNum = 0;
-    let hasConstructor = extractCtorOfClass(stmt) == undefined ? false : true;
+    let hasConstructor = extractCtorOfClass(stmt) === undefined ? false : true;
 
     for (; propertyIndex < properties.length; propertyIndex++) {
         let prop = properties[propertyIndex];
         let tmpVreg = pandaGen.getTemp();
-        if (prop.getKind() == PropertyKind.Constant) {
+        if (prop.getKind() === PropertyKind.CONSTANT) {
             staticItemsNum++;
             let nameLiteral = new Literal(LiteralTag.STRING, String(prop.getName()));
             classBuffer.addLiterals(nameLiteral);
@@ -85,7 +85,7 @@ export function compileClassDeclaration(compiler: Compiler, stmt: ts.ClassLikeDe
             prop.setCompiled();
         }
 
-        if (prop.getKind() == PropertyKind.Variable) {
+        if (prop.getKind() === PropertyKind.VARIABLE) {
             if (prop.getValue().kind != ts.SyntaxKind.Constructor) {
                 if (jshelpers.hasStaticModifier(prop.getValue())) {
                     staticItemsNum++;
@@ -95,7 +95,9 @@ export function compileClassDeclaration(compiler: Compiler, stmt: ts.ClassLikeDe
             }
 
             if (ts.isMethodDeclaration(prop.getValue())) {
-                let methodLiteral = new Literal(LiteralTag.METHOD, compiler.getCompilerDriver().getFuncInternalName(<ts.MethodDeclaration>prop.getValue(), compiler.getRecorder()));
+                let methodLiteral = new Literal(LiteralTag.METHOD,
+                                                compiler.getCompilerDriver().getFuncInternalName(<ts.MethodDeclaration>prop.getValue(),
+                                                compiler.getRecorder()));
                 let affiliateLiteral = new Literal(LiteralTag.METHODAFFILIATE, getParamLengthOfFunc(<ts.MethodDeclaration>prop.getValue()));
                 classBuffer.addLiterals(methodLiteral, affiliateLiteral);
             } else {
@@ -110,7 +112,7 @@ export function compileClassDeclaration(compiler: Compiler, stmt: ts.ClassLikeDe
         }
 
         pandaGen.freeTemps(tmpVreg);
-        if (prop.getKind() == PropertyKind.Computed || prop.getKind() == PropertyKind.Accessor) {
+        if (prop.getKind() === PropertyKind.COMPUTED || prop.getKind() === PropertyKind.ACCESSOR) {
             break;
         }
     }
@@ -161,7 +163,7 @@ export function compileClassDeclaration(compiler: Compiler, stmt: ts.ClassLikeDe
     compiler.popScope();
 }
 
-export function AddCtor2Class(recorder: Recorder, classNode: ts.ClassLikeDeclaration, scope: Scope) {
+export function AddCtor2Class(recorder: Recorder, classNode: ts.ClassLikeDeclaration, scope: Scope): void {
     let ctorNode;
     if (jshelpers.getClassExtendsHeritageElement(classNode)) {
         let parameter = ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createToken(ts.SyntaxKind.DotDotDotToken), "args");
@@ -197,18 +199,18 @@ export function AddCtor2Class(recorder: Recorder, classNode: ts.ClassLikeDeclara
     recorder.setCtorOfClass(classNode, ctorNode);
 }
 
-export function compileDefaultConstructor(compiler: Compiler, ctrNode: ts.ConstructorDeclaration) {
+export function compileDefaultConstructor(compiler: Compiler, ctrNode: ts.ConstructorDeclaration): void {
     let callNode = ts.factory.createCallExpression(ts.factory.createSuper(), undefined,
         [ts.factory.createSpreadElement(ts.factory.createIdentifier("args"))]);
 
     callNode = jshelpers.setParent(callNode, ctrNode)!;
-    callNode = ts.setTextRange(callNode, ctrNode)!
+    callNode = ts.setTextRange(callNode, ctrNode)!;
 
     compileSuperCall(compiler, callNode, [], true);
     compileConstructor(compiler, ctrNode, false);
 }
 
-function compileUnCompiledProperty(compiler: Compiler, properties: Property[], classReg: VReg) {
+function compileUnCompiledProperty(compiler: Compiler, properties: Property[], classReg: VReg): void {
     let pandaGen = compiler.getPandaGen();
     for (let propertyIndex = 0; propertyIndex < properties.length; propertyIndex++) {
         let prop = properties[propertyIndex];
@@ -217,20 +219,20 @@ function compileUnCompiledProperty(compiler: Compiler, properties: Property[], c
         }
 
         switch (prop.getKind()) {
-            case PropertyKind.Constant:
+            case PropertyKind.CONSTANT:
                 compiler.compileExpression(<ts.Expression>prop.getValue());
                 pandaGen.storeOwnProperty(prop.getValue().parent, classReg, <string | number>prop.getName());
                 break;
-            case PropertyKind.Variable:
+            case PropertyKind.VARIABLE:
                 compileUnCompiledVariable(compiler, prop, classReg);
                 break;
-            case PropertyKind.Computed:
+            case PropertyKind.COMPUTED:
                 let keyReg = pandaGen.getTemp();
                 compiler.compileExpression((<ts.ComputedPropertyName>prop.getName()).expression);
                 pandaGen.storeAccumulator(prop.getValue(), keyReg);
                 compileComputedProperty(compiler, prop, classReg, keyReg);
                 break;
-            case PropertyKind.Accessor:
+            case PropertyKind.ACCESSOR:
                 setClassAccessor(pandaGen, compiler, classReg, prop);
                 break;
             default:
@@ -239,7 +241,7 @@ function compileUnCompiledProperty(compiler: Compiler, properties: Property[], c
     }
 }
 
-function compileUnCompiledVariable(compiler: Compiler, prop: Property, classReg: VReg) {
+function compileUnCompiledVariable(compiler: Compiler, prop: Property, classReg: VReg): void {
     let pandaGen = compiler.getPandaGen();
     let proptoReg = pandaGen.getTemp();
     let tmpReg = pandaGen.getTemp();
@@ -259,7 +261,7 @@ function compileUnCompiledVariable(compiler: Compiler, prop: Property, classReg:
 }
 
 function createClassLiteralBuf(compiler: Compiler, classBuffer: LiteralBuffer,
-    stmt: ts.ClassLikeDeclaration, vregs: VReg[]) {
+    stmt: ts.ClassLikeDeclaration, vregs: VReg[]): void {
     let litId: string = PandaGen.appendLiteralArrayBuffer(classBuffer);
 
     let ctorNode = compiler.getRecorder().getCtorOfClass(stmt);
@@ -271,7 +273,7 @@ function createClassLiteralBuf(compiler: Compiler, classBuffer: LiteralBuffer,
     pandaGen.storeAccumulator(stmt, vregs[1]);
 }
 
-export function compileDefaultInitClassMembers(compiler: Compiler, node: ts.ConstructorDeclaration) {
+export function compileDefaultInitClassMembers(compiler: Compiler, node: ts.ConstructorDeclaration): void {
     let pandaGen = compiler.getPandaGen();
     let members = node.parent!.members;
     for (let index = 0; index < members.length; index++) {
@@ -310,7 +312,7 @@ export function compileDefaultInitClassMembers(compiler: Compiler, node: ts.Cons
                     break;
                 }
                 default:
-                    throw new Error("Private Identifier has not been supported")
+                    throw new Error("Private Identifier has not been supported");
 
             }
 
@@ -319,7 +321,7 @@ export function compileDefaultInitClassMembers(compiler: Compiler, node: ts.Cons
     }
 }
 
-export function compileReturnThis4Ctor(compiler: Compiler, node: ts.ConstructorDeclaration, unreachableFlag: boolean) {
+export function compileReturnThis4Ctor(compiler: Compiler, node: ts.ConstructorDeclaration, unreachableFlag: boolean): void {
     let pandaGen = compiler.getPandaGen();
 
     if (unreachableFlag) {
@@ -336,7 +338,7 @@ export function compileReturnThis4Ctor(compiler: Compiler, node: ts.ConstructorD
     pandaGen.freeTemps(thisReg);
 }
 
-export function compileConstructor(compiler: Compiler, node: ts.ConstructorDeclaration, unreachableFlag: boolean) {
+export function compileConstructor(compiler: Compiler, node: ts.ConstructorDeclaration, unreachableFlag: boolean): void {
     let pandaGen = compiler.getPandaGen();
     let members = node.parent!.members;
 
@@ -365,7 +367,7 @@ export function compileConstructor(compiler: Compiler, node: ts.ConstructorDecla
     pandaGen.freeTemps(thisReg);
 }
 
-export function compileSuperCall(compiler: Compiler, node: ts.CallExpression, args: VReg[], hasSpread: boolean) {
+export function compileSuperCall(compiler: Compiler, node: ts.CallExpression, args: VReg[], hasSpread: boolean): void {
     let pandaGen = compiler.getPandaGen();
 
     if (hasSpread) {
@@ -377,7 +379,7 @@ export function compileSuperCall(compiler: Compiler, node: ts.CallExpression, ar
     } else {
         let num = args.length;
         loadCtorObj(node, compiler);
-        pandaGen.superCall(node, num, num ? args : [getVregisterCache(pandaGen, CacheList.undefined)]);
+        pandaGen.superCall(node, num, num ? args : [getVregisterCache(pandaGen, CacheList.UNDEFINED)]);
     }
 
     let tmpReg = pandaGen.getTemp();
@@ -391,7 +393,7 @@ export function compileSuperCall(compiler: Compiler, node: ts.CallExpression, ar
     compiler.setThis(node);
 }
 
-function loadCtorObj(node: ts.CallExpression, compiler: Compiler) {
+function loadCtorObj(node: ts.CallExpression, compiler: Compiler): void {
     let recorder = compiler.getRecorder();
     let pandaGen = compiler.getPandaGen();
     let nearestFunc = jshelpers.getContainingFunctionDeclaration(node);
@@ -423,7 +425,7 @@ function loadCtorObj(node: ts.CallExpression, compiler: Compiler) {
 
 }
 
-export function extractCtorOfClass(stmt: ts.ClassLikeDeclaration) {
+export function extractCtorOfClass(stmt: ts.ClassLikeDeclaration): ts.ConstructorDeclaration {
     let members = stmt.members;
     for (let index = 0; index < members.length; index++) {
         let member = members[index];
@@ -440,9 +442,9 @@ export function defineClassMember(
     propValue: ts.Node,
     propKind: PropertyKind,
     properties: Property[],
-    namedPropertyMap: Map<string, Property>) {
+    namedPropertyMap: Map<string, Property>): boolean {
     let staticFlag = false;
-    if (propKind == PropertyKind.Computed || propKind == PropertyKind.Spread) {
+    if (propKind === PropertyKind.COMPUTED || propKind === PropertyKind.SPREAD) {
         let prop = new Property(propKind, <ts.ComputedPropertyName | undefined>propName);
         prop.setValue(propValue);
         if (jshelpers.hasStaticModifier(propValue)) {
@@ -455,7 +457,7 @@ export function defineClassMember(
         let name_str = propertyKeyAsString(<string | number>propName);
         if (!checkAndUpdateProperty(namedPropertyMap, name_str, propKind, propValue)) {
             let prop = new Property(propKind, propName);
-            if (propKind == PropertyKind.Accessor) {
+            if (propKind === PropertyKind.ACCESSOR) {
                 if (ts.isGetAccessorDeclaration(propValue)) {
                     prop.setGetter(propValue);
                 } else if (ts.isSetAccessorDeclaration(propValue)) {
@@ -476,7 +478,7 @@ export function defineClassMember(
     return staticFlag;
 }
 
-function compileHeritageClause(compiler: Compiler, node: ts.ClassLikeDeclaration) {
+function compileHeritageClause(compiler: Compiler, node: ts.ClassLikeDeclaration): VReg {
     let pandaGen = compiler.getPandaGen();
     let baseVreg = pandaGen.getTemp();
     if (node.heritageClauses && node.heritageClauses.length) {
@@ -493,7 +495,7 @@ function compileHeritageClause(compiler: Compiler, node: ts.ClassLikeDeclaration
     return baseVreg;
 }
 
-export function getClassNameForConstructor(classNode: ts.ClassLikeDeclaration) {
+export function getClassNameForConstructor(classNode: ts.ClassLikeDeclaration): string {
     let className = "";
 
     if (!isAnonymousClass(classNode)) {
@@ -512,7 +514,7 @@ export function getClassNameForConstructor(classNode: ts.ClassLikeDeclaration) {
             }
         } else if (ts.isBinaryExpression(outerNode)) {
             let leftExp = outerNode.left;
-            if (outerNode.operatorToken.kind == ts.SyntaxKind.EqualsToken && ts.isIdentifier(leftExp)) {
+            if (outerNode.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(leftExp)) {
                 className = jshelpers.getTextOfIdentifierOrLiteral(leftExp);
             }
         } else if (ts.isPropertyAssignment(outerNode)) {
@@ -528,11 +530,11 @@ export function getClassNameForConstructor(classNode: ts.ClassLikeDeclaration) {
     return className;
 }
 
-function isAnonymousClass(node: ts.ClassLikeDeclaration) {
+function isAnonymousClass(node: ts.ClassLikeDeclaration): boolean {
     return node.name ? false : true;
 }
 
-function generatePropertyFromExpr(node: ts.ClassLikeDeclaration, classFields: Array<ts.PropertyDeclaration>, namedPropertyMap: Map<string, Property>) {
+function generatePropertyFromExpr(node: ts.ClassLikeDeclaration, classFields: Array<ts.PropertyDeclaration>, namedPropertyMap: Map<string, Property>): Property[] {
     let properties: Array<Property> = [];
     let staticNum = 0;
     let constructNode: any;
@@ -549,7 +551,7 @@ function generatePropertyFromExpr(node: ts.ClassLikeDeclaration, classFields: Ar
                 }
 
                 if (ts.isComputedPropertyName(member.name!)) {
-                    if (defineClassMember(member.name, member, PropertyKind.Computed, properties, namedPropertyMap)) {
+                    if (defineClassMember(member.name, member, PropertyKind.COMPUTED, properties, namedPropertyMap)) {
                         staticNum++;
                     }
                 } else {
@@ -557,17 +559,17 @@ function generatePropertyFromExpr(node: ts.ClassLikeDeclaration, classFields: Ar
                     let initializer = (<ts.PropertyDeclaration>member).initializer;
                     if (initializer) {
                         if (isConstantExpr(initializer)) {
-                            if (defineClassMember(memberName, initializer, PropertyKind.Constant, properties, namedPropertyMap)) {
+                            if (defineClassMember(memberName, initializer, PropertyKind.CONSTANT, properties, namedPropertyMap)) {
                                 staticNum++;
                             }
                         } else {
-                            if (defineClassMember(memberName, initializer, PropertyKind.Variable, properties, namedPropertyMap)) {
+                            if (defineClassMember(memberName, initializer, PropertyKind.VARIABLE, properties, namedPropertyMap)) {
                                 staticNum++;
                             }
                         }
                     } else {
                         initializer = ts.createIdentifier("undefined");
-                        if (defineClassMember(memberName, initializer, PropertyKind.Constant, properties, namedPropertyMap)) {
+                        if (defineClassMember(memberName, initializer, PropertyKind.CONSTANT, properties, namedPropertyMap)) {
                             staticNum++;
                         }
                     }
@@ -576,12 +578,12 @@ function generatePropertyFromExpr(node: ts.ClassLikeDeclaration, classFields: Ar
             }
             case ts.SyntaxKind.MethodDeclaration: {
                 let memberName = getPropName(member.name!);
-                if (typeof (memberName) == 'string' || typeof (memberName) == 'number') {
-                    if (defineClassMember(memberName, member, PropertyKind.Variable, properties, namedPropertyMap)) {
+                if (typeof (memberName) === 'string' || typeof (memberName) === 'number') {
+                    if (defineClassMember(memberName, member, PropertyKind.VARIABLE, properties, namedPropertyMap)) {
                         staticNum++;
                     }
                 } else {
-                    if (defineClassMember(memberName, member, PropertyKind.Computed, properties, namedPropertyMap)) {
+                    if (defineClassMember(memberName, member, PropertyKind.COMPUTED, properties, namedPropertyMap)) {
                         staticNum++;
                     }
                 }
@@ -590,12 +592,12 @@ function generatePropertyFromExpr(node: ts.ClassLikeDeclaration, classFields: Ar
             case ts.SyntaxKind.GetAccessor:
             case ts.SyntaxKind.SetAccessor: {
                 let accessorName = getPropName(member.name!);
-                if (typeof (accessorName) == 'string' || typeof (accessorName) == 'number') {
-                    if (defineClassMember(accessorName, member, PropertyKind.Accessor, properties, namedPropertyMap)) {
+                if (typeof (accessorName) === 'string' || typeof (accessorName) === 'number') {
+                    if (defineClassMember(accessorName, member, PropertyKind.ACCESSOR, properties, namedPropertyMap)) {
                         staticNum++;
                     }
                 } else {
-                    if (defineClassMember(accessorName, member, PropertyKind.Computed, properties, namedPropertyMap)) {
+                    if (defineClassMember(accessorName, member, PropertyKind.COMPUTED, properties, namedPropertyMap)) {
                         staticNum++;
                     }
                 }
@@ -614,19 +616,19 @@ function generatePropertyFromExpr(node: ts.ClassLikeDeclaration, classFields: Ar
      * Need to reverse the order of non-static members
      */
 
-    let staticItems = properties.slice(properties.length - staticNum)
+    let staticItems = properties.slice(properties.length - staticNum);
     properties = properties.slice(0, properties.length - staticNum);
     properties = properties.reverse();
     properties.push(...staticItems);
 
     if (constructNode) {
-        defineClassMember("constructor", constructNode, PropertyKind.Variable, properties, namedPropertyMap);
+        defineClassMember("constructor", constructNode, PropertyKind.VARIABLE, properties, namedPropertyMap);
     }
 
     return properties;
 }
 
-function compileComputedProperty(compiler: Compiler, prop: Property, classReg: VReg, keyReg: VReg) {
+function compileComputedProperty(compiler: Compiler, prop: Property, classReg: VReg, keyReg: VReg): void {
     let pandaGen = compiler.getPandaGen();
     switch (prop.getValue().kind) {
         case ts.SyntaxKind.PropertyDeclaration: {
@@ -650,7 +652,8 @@ function compileComputedProperty(compiler: Compiler, prop: Property, classReg: V
             let getProtoReg = pandaGen.getTemp();
             let getter = <ts.GetAccessorDeclaration>prop.getValue();
             let getFlag = createClassMethodOrAccessor(compiler, classReg, getProtoReg, accessorReg, getter);
-            pandaGen.defineGetterSetterByValue(getter, getFlag ? getProtoReg : classReg, keyReg, accessorReg, getVregisterCache(pandaGen, CacheList.undefined), true);
+            pandaGen.defineGetterSetterByValue(getter, getFlag ? getProtoReg : classReg, keyReg, accessorReg,
+                                               getVregisterCache(pandaGen, CacheList.UNDEFINED), true);
             pandaGen.freeTemps(accessorReg, getProtoReg);
             break;
         }
@@ -659,7 +662,8 @@ function compileComputedProperty(compiler: Compiler, prop: Property, classReg: V
             let setter = <ts.SetAccessorDeclaration>prop.getValue();
             let setProtoReg = pandaGen.getTemp();
             let setFlag = createClassMethodOrAccessor(compiler, classReg, setProtoReg, accesReg, setter);
-            pandaGen.defineGetterSetterByValue(setter, setFlag ? setProtoReg : classReg, keyReg, getVregisterCache(pandaGen, CacheList.undefined), accesReg, true);
+            pandaGen.defineGetterSetterByValue(setter, setFlag ? setProtoReg : classReg, keyReg,
+                                               getVregisterCache(pandaGen, CacheList.UNDEFINED), accesReg, true);
             pandaGen.freeTemps(accesReg, setProtoReg);
             break;
         }
@@ -669,7 +673,7 @@ function compileComputedProperty(compiler: Compiler, prop: Property, classReg: V
     pandaGen.freeTemps(keyReg);
 }
 
-function setClassAccessor(pandaGen: PandaGen, compiler: Compiler, objReg: VReg, prop: Property) {
+function setClassAccessor(pandaGen: PandaGen, compiler: Compiler, objReg: VReg, prop: Property): void {
 
     let getterReg = pandaGen.getTemp();
     let setterReg = pandaGen.getTemp();
@@ -696,16 +700,16 @@ function setClassAccessor(pandaGen: PandaGen, compiler: Compiler, objReg: VReg,
     if (prop.getGetter() !== undefined && prop.getSetter() !== undefined) {
         pandaGen.defineGetterSetterByValue(accessor!, flag ? tmpVreg : objReg, propReg, getterReg, setterReg, false);
     } else if (ts.isGetAccessorDeclaration(accessor!)) {
-        pandaGen.defineGetterSetterByValue(accessor, flag ? tmpVreg : objReg, propReg, getterReg, getVregisterCache(pandaGen, CacheList.undefined), false);
+        pandaGen.defineGetterSetterByValue(accessor, flag ? tmpVreg : objReg, propReg, getterReg, getVregisterCache(pandaGen, CacheList.UNDEFINED), false);
     } else {
-        pandaGen.defineGetterSetterByValue(accessor!, flag ? tmpVreg : objReg, propReg, getVregisterCache(pandaGen, CacheList.undefined), setterReg, false);
+        pandaGen.defineGetterSetterByValue(accessor!, flag ? tmpVreg : objReg, propReg, getVregisterCache(pandaGen, CacheList.UNDEFINED), setterReg, false);
     }
 
     pandaGen.freeTemps(getterReg, setterReg, propReg, tmpVreg);
 }
 
 function createClassMethodOrAccessor(compiler: Compiler, classReg: VReg, propReg: VReg, storeReg: VReg,
-    node: ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.ConstructorDeclaration) {
+    node: ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.ConstructorDeclaration): boolean {
     let pandaGen = compiler.getPandaGen();
     if (jshelpers.hasStaticModifier(node)) {
         createMethodOrAccessor(pandaGen, compiler, classReg, node);
@@ -721,12 +725,12 @@ function createClassMethodOrAccessor(compiler: Compiler, classReg: VReg, propReg
     return true;
 }
 
-function scalarArrayEquals(node1: ts.Node | undefined, node2: ts.Node | undefined) {
+function scalarArrayEquals(node1: ts.Node | undefined, node2: ts.Node | undefined): boolean {
     if (node1 && node2) {
         let val1Modifs = node1.modifiers;
         let val2Modifs = node2.modifiers;
         if (val1Modifs && val2Modifs) {
-            return val1Modifs.length == val2Modifs.length && val1Modifs.every(function (v, i) { return v === val2Modifs![i] });;
+            return val1Modifs.length === val2Modifs.length && val1Modifs.every(function (v, i) { return v === val2Modifs![i] });
         }
 
         if (!val1Modifs && !val2Modifs) {
@@ -739,7 +743,7 @@ function scalarArrayEquals(node1: ts.Node | undefined, node2: ts.Node | undefine
     return false;
 }
 
-export function setPrototypeAttributes(compiler: Compiler, node: ts.Node, classReg: VReg, propReg: VReg, storeReg: VReg) {
+export function setPrototypeAttributes(compiler: Compiler, node: ts.Node, classReg: VReg, propReg: VReg, storeReg: VReg): boolean {
     let pandaGen = compiler.getPandaGen();
     pandaGen.storeAccumulator(node, storeReg);
     if (jshelpers.hasStaticModifier(node)) {
@@ -754,7 +758,7 @@ export function setPrototypeAttributes(compiler: Compiler, node: ts.Node, classR
 function checkAndUpdateProperty(namedPropertyMap: Map<string, Property>, name: string, propKind: PropertyKind, valueNode: ts.Node): boolean {
     if (namedPropertyMap.has(name)) {
         let prop = namedPropertyMap.get(name);
-        if (propKind == PropertyKind.Accessor) {
+        if (propKind === PropertyKind.ACCESSOR) {
             if (ts.isGetAccessorDeclaration(valueNode)) {
                 if (!scalarArrayEquals(prop!.getGetter(), valueNode)) {
                     return false;
@@ -785,14 +789,14 @@ export function shouldReturnThisForConstruct(stmt: ts.ReturnStatement): boolean
         return false;
     }
 
-    if (!expr || isUndefinedIdentifier(expr) || expr.kind == ts.SyntaxKind.ThisKeyword) {
+    if (!expr || isUndefinedIdentifier(expr) || expr.kind === ts.SyntaxKind.ThisKeyword) {
         return true;
     }
 
     return false;
 }
 
-export function compileSuperProperty(compiler: Compiler, expr: ts.Expression, thisReg: VReg, prop: VReg | string | number) {
+export function compileSuperProperty(compiler: Compiler, expr: ts.Expression, thisReg: VReg, prop: VReg | string | number): void {
     checkValidUseSuperBeforeSuper(compiler, expr);
     let pandaGen = compiler.getPandaGen();
     compiler.getThis(expr, thisReg);
@@ -800,7 +804,7 @@ export function compileSuperProperty(compiler: Compiler, expr: ts.Expression, th
     pandaGen.loadSuperProperty(expr, thisReg, prop);
 }
 
-export function checkValidUseSuperBeforeSuper(compiler: Compiler, node: ts.Node) {
+export function checkValidUseSuperBeforeSuper(compiler: Compiler, node: ts.Node): void {
     let pandaGen = compiler.getPandaGen();
     let ctorNode = jshelpers.findAncestor(node, ts.isConstructorDeclaration);
 
@@ -815,8 +819,8 @@ export function checkValidUseSuperBeforeSuper(compiler: Compiler, node: ts.Node)
 
     if (jshelpers.isSuperProperty(node) ||
         ts.isConstructorDeclaration(node) ||
-        node.kind == ts.SyntaxKind.ThisKeyword ||
-        node.kind == ts.SyntaxKind.ReturnStatement) {
+        node.kind === ts.SyntaxKind.ThisKeyword ||
+        node.kind === ts.SyntaxKind.ReturnStatement) {
         pandaGen.throwIfSuperNotCorrectCall(ctorNode, 0);
     }
 
diff --git a/ts2panda/src/statement/forOfStatement.ts b/ts2panda/src/statement/forOfStatement.ts
index d4f1dede5a..5799eac750 100644
--- a/ts2panda/src/statement/forOfStatement.ts
+++ b/ts2panda/src/statement/forOfStatement.ts
@@ -38,21 +38,21 @@ export class IteratorRecord {
         this.nextMethod = nextMethod;
     }
 
-    getType() {
+    getType(): IteratorType {
         return this.type;
     }
 
-    getObject() {
+    getObject(): VReg {
         return this.object;
     }
 
-    getNextMethod() {
+    getNextMethod(): VReg {
         return this.nextMethod;
     }
 }
 
 
-export function compileForOfStatement(stmt: ts.ForOfStatement, compiler: Compiler) {
+export function compileForOfStatement(stmt: ts.ForOfStatement, compiler: Compiler): void {
     compiler.pushScope(stmt);
 
     let pandaGen = compiler.getPandaGen();
@@ -83,7 +83,7 @@ export function compileForOfStatement(stmt: ts.ForOfStatement, compiler: Compile
         compiler.popEnv();
     }
 
-    pandaGen.loadAccumulator(stmt, getVregisterCache(pandaGen, CacheList.False));
+    pandaGen.loadAccumulator(stmt, getVregisterCache(pandaGen, CacheList.FALSE));
     pandaGen.storeAccumulator(stmt, doneReg);
 
     let labelTarget = new LabelTarget(stmt, endLabel, nextLabel, needCreateLoopEnv);
@@ -107,7 +107,7 @@ export function compileForOfStatement(stmt: ts.ForOfStatement, compiler: Compile
     compiler.popScope();
 }
 
-export function getIteratorRecord(pandagen: PandaGen, node: ts.Node, nextMethod: VReg, object: VReg, type: IteratorType) {
+export function getIteratorRecord(pandagen: PandaGen, node: ts.Node, nextMethod: VReg, object: VReg, type: IteratorType): IteratorRecord {
     getIterator(pandagen, node, type);
 
     pandagen.storeAccumulator(node, object);
@@ -117,8 +117,8 @@ export function getIteratorRecord(pandagen: PandaGen, node: ts.Node, nextMethod:
     return new IteratorRecord(object, nextMethod, type);
 }
 
-function getIterator(pandagen: PandaGen, node: ts.Node, type: IteratorType) {
-    if (type == IteratorType.Async) {
+function getIterator(pandagen: PandaGen, node: ts.Node, type: IteratorType): void {
+    if (type === IteratorType.Async) {
         pandagen.getAsyncIterator(node);
     } else {
         pandagen.getIterator(node);
diff --git a/ts2panda/src/statement/labelTarget.ts b/ts2panda/src/statement/labelTarget.ts
index bfd71326a8..fd7a1b0833 100644
--- a/ts2panda/src/statement/labelTarget.ts
+++ b/ts2panda/src/statement/labelTarget.ts
@@ -44,44 +44,44 @@ export class LabelTarget {
         }
     }
 
-    containLoopEnv() {
+    containLoopEnv(): boolean {
         return this.hasLoopEnv;
     }
 
-    getBreakTargetLabel() {
+    getBreakTargetLabel(): Label {
         return this.breakTargetLabel;
     }
 
-    getContinueTargetLabel() {
+    getContinueTargetLabel(): any {
         return this.continueTargetLabel;
     }
 
-    getLoopEnvLevel() {
+    getLoopEnvLevel(): number {
         return this.loopEnvLevel;
     }
 
-    getTryStatement() {
+    getTryStatement(): TryStatement {
         return this.tryStatement;
     }
 
-    getPreLoopLabelTarget() {
+    getPreLoopLabelTarget(): LabelTarget {
         return this.preLoopLabelTarget;
     }
 
-    getCorrespondingNode() {
+    getCorrespondingNode(): ts.Node {
         return this.node;
     }
 
-    private increaseLoopEnvLevel() {
+    private increaseLoopEnvLevel(): void {
         this.loopEnvLevel += 1;
     }
 
-    private decreaseLoopEnvLevel() {
+    private decreaseLoopEnvLevel(): void {
         this.loopEnvLevel -= 1;
     }
 
     private static isLabelTargetsEmpty(): boolean {
-        if (LabelTarget.labelTargetStack.length == 0) {
+        if (LabelTarget.labelTargetStack.length === 0) {
             return true;
         }
         return false;
@@ -94,7 +94,7 @@ export class LabelTarget {
         return undefined;
     }
 
-    static pushLabelTarget(labelTarget: LabelTarget) {
+    static pushLabelTarget(labelTarget: LabelTarget): void {
         if (labelTarget.hasLoopEnv) {
             if (TryStatement.getCurrentTryStatement()) {
                 TryStatement.getCurrentTryStatement().increaseLoopEnvLevel();
@@ -104,7 +104,7 @@ export class LabelTarget {
         LabelTarget.labelTargetStack.push(labelTarget);
     }
 
-    static popLabelTarget() {
+    static popLabelTarget(): void {
         if (!LabelTarget.isLabelTargetsEmpty()) {
             let popedLabelTarget = LabelTarget.labelTargetStack.pop();
             if (popedLabelTarget.containLoopEnv()) {
@@ -119,8 +119,8 @@ export class LabelTarget {
         }
     }
 
-    static updateName2LabelTarget(node: ts.Node, labelTarget: LabelTarget) {
-        while (node.kind == ts.SyntaxKind.LabeledStatement) {
+    static updateName2LabelTarget(node: ts.Node, labelTarget: LabelTarget): void {
+        while (node.kind === ts.SyntaxKind.LabeledStatement) {
             let labeledStmt = <ts.LabeledStatement>node;
             let labelName = jshelpers.getTextOfIdentifierOrLiteral(labeledStmt.label);
 
@@ -134,11 +134,11 @@ export class LabelTarget {
         }
     }
 
-    static deleteName2LabelTarget(labelName: string) {
+    static deleteName2LabelTarget(labelName: string): void {
         LabelTarget.name2LabelTarget.delete(labelName);
     }
 
-    static getCurLoopLabelTarget() {
+    static getCurLoopLabelTarget(): LabelTarget {
         return LabelTarget.curLoopLabelTarget;
     }
 
diff --git a/ts2panda/src/statement/loopStatement.ts b/ts2panda/src/statement/loopStatement.ts
index e1c02b44e8..ad932fc44b 100644
--- a/ts2panda/src/statement/loopStatement.ts
+++ b/ts2panda/src/statement/loopStatement.ts
@@ -32,7 +32,7 @@ import { Label, VReg } from "../irnodes";
 import { LoopScope, Scope } from "../scope";
 import { LabelTarget } from "./labelTarget";
 
-export function compileDoStatement(stmt: ts.DoStatement, compiler: Compiler) {
+export function compileDoStatement(stmt: ts.DoStatement, compiler: Compiler): void {
     compiler.pushScope(stmt);
     let pandaGen = compiler.getPandaGen();
 
@@ -72,7 +72,7 @@ export function compileDoStatement(stmt: ts.DoStatement, compiler: Compiler) {
     compiler.popScope();
 }
 
-export function compileWhileStatement(stmt: ts.WhileStatement, compiler: Compiler) {
+export function compileWhileStatement(stmt: ts.WhileStatement, compiler: Compiler): void {
     compiler.pushScope(stmt);
     let pandaGen = compiler.getPandaGen();
 
@@ -102,14 +102,14 @@ export function compileWhileStatement(stmt: ts.WhileStatement, compiler: Compile
 
     if (needCreateLoopEnv) {
         pandaGen.popLexicalEnv(stmt);
-        compiler.popEnv()
+        compiler.popEnv();
     }
 
     LabelTarget.popLabelTarget();
     compiler.popScope();
 }
 
-export function compileForStatement(stmt: ts.ForStatement, compiler: Compiler) {
+export function compileForStatement(stmt: ts.ForStatement, compiler: Compiler): void {
     compiler.pushScope(stmt);
     let pandaGen = compiler.getPandaGen();
 
@@ -247,7 +247,7 @@ export function compileForStatement(stmt: ts.ForStatement, compiler: Compiler) {
     compiler.popScope();
 }
 
-export function compileForInStatement(stmt: ts.ForInStatement, compiler: Compiler) {
+export function compileForInStatement(stmt: ts.ForInStatement, compiler: Compiler): void {
     compiler.pushScope(stmt);
     let pandaGen = compiler.getPandaGen();
 
@@ -287,7 +287,7 @@ export function compileForInStatement(stmt: ts.ForInStatement, compiler: Compile
     // get next prop of enumerator
     pandaGen.getNextPropName(stmt, iterReg);
     pandaGen.storeAccumulator(stmt, propName);
-    pandaGen.condition(stmt, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.undefined), loopEndLabel);
+    pandaGen.condition(stmt, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.UNDEFINED), loopEndLabel);
 
     let lref = LReference.generateLReference(compiler, stmt.initializer, false);
     pandaGen.loadAccumulator(stmt, propName);
diff --git a/ts2panda/src/statement/returnStatement.ts b/ts2panda/src/statement/returnStatement.ts
index 6b4365aa7a..6d7120804b 100644
--- a/ts2panda/src/statement/returnStatement.ts
+++ b/ts2panda/src/statement/returnStatement.ts
@@ -22,7 +22,7 @@ import { Label, VReg } from "../irnodes";
 import * as jshelpers from "../jshelpers";
 import { checkValidUseSuperBeforeSuper } from "./classStatement";
 
-export function compileReturnStatement(stmt: ts.ReturnStatement, compiler: Compiler) {
+export function compileReturnStatement(stmt: ts.ReturnStatement, compiler: Compiler): void {
     let pandaGen = compiler.getPandaGen();
     let returnValue = pandaGen.getTemp();
 
@@ -34,26 +34,26 @@ export function compileReturnStatement(stmt: ts.ReturnStatement, compiler: Compi
     pandaGen.freeTemps(returnValue);
 }
 
-function compileReturnInDerivedCtor(stmt: ts.ReturnStatement, returnValue: VReg, compiler: Compiler) {
+function compileReturnInDerivedCtor(stmt: ts.ReturnStatement, returnValue: VReg, compiler: Compiler): void {
     let pandaGen = compiler.getPandaGen();
     let expr = stmt.expression;
 
     let need2CheckSuper = pandaGen.getTemp();
 
     if (!expr) {
-        pandaGen.moveVreg(stmt, need2CheckSuper, getVregisterCache(pandaGen, CacheList.True));
+        pandaGen.moveVreg(stmt, need2CheckSuper, getVregisterCache(pandaGen, CacheList.TRUE));
     } else {
-        if (ts.isCallExpression(expr) && expr.expression.kind == ts.SyntaxKind.SuperKeyword) {
+        if (ts.isCallExpression(expr) && expr.expression.kind === ts.SyntaxKind.SuperKeyword) {
             compileNormalReturn(stmt, returnValue, compiler);
             pandaGen.freeTemps(need2CheckSuper);
             return;
         }
 
-        if (expr.kind == ts.SyntaxKind.ThisKeyword) {
-            pandaGen.moveVreg(stmt, need2CheckSuper, getVregisterCache(pandaGen, CacheList.True));
+        if (expr.kind === ts.SyntaxKind.ThisKeyword) {
+            pandaGen.moveVreg(stmt, need2CheckSuper, getVregisterCache(pandaGen, CacheList.TRUE));
         } else {
             compiler.compileExpression(expr);
-            pandaGen.binary(stmt, ts.SyntaxKind.EqualsEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.undefined));
+            pandaGen.binary(stmt, ts.SyntaxKind.EqualsEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.UNDEFINED));
             pandaGen.storeAccumulator(stmt, need2CheckSuper);
         }
     }
@@ -61,7 +61,7 @@ function compileReturnInDerivedCtor(stmt: ts.ReturnStatement, returnValue: VReg,
     let compile = new Label();
     let notCompile = new Label();
     pandaGen.loadAccumulator(stmt, need2CheckSuper);
-    pandaGen.condition(stmt, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.False), compile);
+    pandaGen.condition(stmt, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.FALSE), compile);
 
     // load this
     let thisReg = pandaGen.getTemp();
@@ -74,7 +74,7 @@ function compileReturnInDerivedCtor(stmt: ts.ReturnStatement, returnValue: VReg,
     if (expr) {
         compiler.compileExpression(expr);
     } else {
-        pandaGen.loadAccumulator(stmt, getVregisterCache(pandaGen, CacheList.undefined));
+        pandaGen.loadAccumulator(stmt, getVregisterCache(pandaGen, CacheList.UNDEFINED));
     }
 
     pandaGen.label(stmt, notCompile);
@@ -89,7 +89,7 @@ function compileReturnInDerivedCtor(stmt: ts.ReturnStatement, returnValue: VReg,
     let returnLabel = new Label();
     let normalLabel = new Label();
     pandaGen.loadAccumulator(stmt, need2CheckSuper);
-    pandaGen.condition(stmt, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.False), normalLabel);
+    pandaGen.condition(stmt, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.FALSE), normalLabel);
     // check if super has been called
     checkValidUseSuperBeforeSuper(compiler, stmt);
     pandaGen.branch(stmt, returnLabel);
@@ -104,7 +104,7 @@ function compileReturnInDerivedCtor(stmt: ts.ReturnStatement, returnValue: VReg,
     pandaGen.freeTemps(need2CheckSuper, thisReg);
 }
 
-function compileNormalReturn(stmt: ts.ReturnStatement, returnValue: VReg, compiler: Compiler) {
+function compileNormalReturn(stmt: ts.ReturnStatement, returnValue: VReg, compiler: Compiler): void {
     let expr = stmt.expression;
     let pandaGen = compiler.getPandaGen();
     let empty : boolean = false;
@@ -113,7 +113,7 @@ function compileNormalReturn(stmt: ts.ReturnStatement, returnValue: VReg, compil
         compiler.compileExpression(expr);
     } else {
         empty = true;
-        pandaGen.loadAccumulator(stmt, getVregisterCache(pandaGen, CacheList.undefined));
+        pandaGen.loadAccumulator(stmt, getVregisterCache(pandaGen, CacheList.UNDEFINED));
     }
     pandaGen.storeAccumulator(stmt, returnValue);
 
@@ -127,7 +127,7 @@ function compileNormalReturn(stmt: ts.ReturnStatement, returnValue: VReg, compil
     compiler.getFuncBuilder().explicitReturn(stmt, empty);
 }
 
-function isReturnInDerivedCtor(stmt: ts.ReturnStatement) {
+function isReturnInDerivedCtor(stmt: ts.ReturnStatement): boolean {
     let funcNode = jshelpers.getContainingFunctionDeclaration(stmt);
     if (!funcNode || !ts.isConstructorDeclaration(funcNode)) {
         return false;
diff --git a/ts2panda/src/statement/switchStatement.ts b/ts2panda/src/statement/switchStatement.ts
index 180587a66b..06768676fa 100644
--- a/ts2panda/src/statement/switchStatement.ts
+++ b/ts2panda/src/statement/switchStatement.ts
@@ -23,7 +23,7 @@ import { Compiler } from "../compiler";
 import {
     DiagnosticCode,
     DiagnosticError
-} from "../diagnostic"
+} from "../diagnostic";
 import { LabelTarget } from "./labelTarget";
 export class SwitchBase {
     private stmt: ts.SwitchStatement;
diff --git a/ts2panda/src/statement/tryStatement.ts b/ts2panda/src/statement/tryStatement.ts
index f20de8ef20..4a9c0504d7 100644
--- a/ts2panda/src/statement/tryStatement.ts
+++ b/ts2panda/src/statement/tryStatement.ts
@@ -81,20 +81,20 @@ export class CatchTable {
         pandaGen.getCatchMap().set(catchBeginLabel, this);
     }
 
-    getLabelPairs() {
+    getLabelPairs(): LabelPair[] {
         return this.labelPairs;
     }
 
-    getCatchBeginLabel() {
+    getCatchBeginLabel(): Label {
         return this.catchBeginLabel;
     }
 
-    getDepth() {
+    getDepth(): number {
         return this.depth;
     }
 
     // split the last labelPair after inline finally.
-    splitLabelPair(inlinedLabelPair: LabelPair) {
+    splitLabelPair(inlinedLabelPair: LabelPair): void {
         let lastLabelPair = this.labelPairs.pop();
         if (lastLabelPair) {
             this.labelPairs.push(new LabelPair(lastLabelPair.getBeginLabel(), inlinedLabelPair.getBeginLabel()));
@@ -139,44 +139,44 @@ export class TryStatement {
         TryStatement.currentTryStatement = this;
     }
 
-    destroy() {
+    destroy(): void {
         TryStatement.currentTryStatementDepth--;
         TryStatement.currentTryStatement = this.outer;
     }
 
-    static setCurrentTryStatement(tryStatement: TryStatement | undefined) {
+    static setCurrentTryStatement(tryStatement: TryStatement | undefined): void {
         TryStatement.currentTryStatement = tryStatement;
     }
 
-    static getCurrentTryStatement() {
+    static getCurrentTryStatement(): TryStatement {
         return TryStatement.currentTryStatement;
     }
 
-    static getcurrentTryStatementDepth() {
+    static getcurrentTryStatementDepth(): number {
         return TryStatement.currentTryStatementDepth;
     }
 
-    getOuterTryStatement() {
+    getOuterTryStatement(): TryStatement {
         return this.outer;
     }
 
-    getStatement() {
+    getStatement(): ts.Statement {
         return this.stmt;
     }
 
-    getCatchTable() {
+    getCatchTable(): CatchTable {
         return this.catchTable;
     }
 
-    getLoopEnvLevel() {
+    getLoopEnvLevel(): number {
         return this.loopEnvLevel;
     }
 
-    increaseLoopEnvLevel() {
+    increaseLoopEnvLevel(): void {
         this.loopEnvLevel += 1;
     }
 
-    decreaseLoopEnvLevel() {
+    decreaseLoopEnvLevel(): void {
         this.loopEnvLevel -= 1;
     }
 }
@@ -204,10 +204,10 @@ export abstract class TryBuilderBase {
 export class TryBuilder extends TryBuilderBase {
 
     constructor(compiler: Compiler, pandaGen: PandaGen, tryStmt: ts.TryStatement) {
-        super(compiler, pandaGen, tryStmt)
+        super(compiler, pandaGen, tryStmt);
     }
 
-    compileTryBlock(catchTable: CatchTable) {
+    compileTryBlock(catchTable: CatchTable): void {
         if ((<ts.TryStatement>this.stmt).finallyBlock) {
             this.tryStatement = new TryStatement(this.stmt, catchTable, this);
         } else {
@@ -220,13 +220,13 @@ export class TryBuilder extends TryBuilderBase {
         this.tryStatement.destroy();
     }
 
-    compileFinallyBlockIfExisted() {
+    compileFinallyBlockIfExisted(): void {
         if ((<ts.TryStatement>this.stmt).finallyBlock) {
             this.compiler.compileStatement((<ts.TryStatement>this.stmt).finallyBlock!);
         }
     }
 
-    compileExceptionHandler() {
+    compileExceptionHandler(): void {
         let catchClause = (<ts.TryStatement>this.stmt).catchClause;
         if (catchClause) {
             this.compiler.pushScope(catchClause);
@@ -248,7 +248,7 @@ export class TryBuilder extends TryBuilderBase {
     }
 
     // @ts-ignore
-    compileFinalizer(cfc: ControlFlowChange, continueTargetLabel: Label) {
+    compileFinalizer(cfc: ControlFlowChange, continueTargetLabel: Label): void {
         this.compiler.compileStatement((<ts.TryStatement>this.stmt).finallyBlock!);
     }
 }
@@ -260,7 +260,8 @@ export class TryBuilderWithForOf extends TryBuilderBase {
     private hasLoopEnv: boolean;
     private loopEnv: VReg | undefined;
 
-    constructor(compiler: Compiler, pandaGen: PandaGen, forOfStmt: ts.ForOfStatement, doneReg: VReg, iterator: IteratorRecord, labelTarget: LabelTarget, hasLoopEnv: boolean, loopEnv?: VReg) {
+    constructor(compiler: Compiler, pandaGen: PandaGen, forOfStmt: ts.ForOfStatement, doneReg: VReg, iterator: IteratorRecord,
+                labelTarget: LabelTarget, hasLoopEnv: boolean, loopEnv?: VReg) {
         super(compiler, pandaGen, forOfStmt);
 
         this.labelTarget = labelTarget;
@@ -270,7 +271,7 @@ export class TryBuilderWithForOf extends TryBuilderBase {
         this.loopEnv = loopEnv ? loopEnv : undefined;
     }
 
-    compileTryBlock(catchTable: CatchTable) {
+    compileTryBlock(catchTable: CatchTable): void {
         let stmt = <ts.ForOfStatement>this.stmt;
         let compiler = <Compiler>this.compiler;
         let pandaGen = this.pandaGen;
@@ -281,7 +282,7 @@ export class TryBuilderWithForOf extends TryBuilderBase {
 
         let loopScope = <LoopScope>compiler.getRecorder().getScopeOfNode(stmt);
 
-        pandaGen.loadAccumulator(stmt, getVregisterCache(pandaGen, CacheList.True));
+        pandaGen.loadAccumulator(stmt, getVregisterCache(pandaGen, CacheList.TRUE));
         pandaGen.storeAccumulator(stmt, this.doneReg);
 
         pandaGen.label(stmt, this.labelTarget.getContinueTargetLabel()!);
@@ -297,7 +298,7 @@ export class TryBuilderWithForOf extends TryBuilderBase {
         pandaGen.loadObjProperty(stmt, resultReg, "value");
         pandaGen.storeAccumulator(stmt, resultReg);
 
-        pandaGen.loadAccumulator(stmt, getVregisterCache(pandaGen, CacheList.False));
+        pandaGen.loadAccumulator(stmt, getVregisterCache(pandaGen, CacheList.FALSE));
         pandaGen.storeAccumulator(stmt, this.doneReg);
 
         let lref = LReference.generateLReference(this.compiler, stmt.initializer, isDeclaration);
@@ -309,9 +310,9 @@ export class TryBuilderWithForOf extends TryBuilderBase {
         pandaGen.freeTemps(resultReg);
     }
 
-    compileFinallyBlockIfExisted() { }
+    compileFinallyBlockIfExisted(): void { }
 
-    compileExceptionHandler() {
+    compileExceptionHandler(): void {
         let pandaGen = this.pandaGen;
         let noReturn = new Label();
         let exceptionVreg = pandaGen.getTemp();
@@ -321,14 +322,14 @@ export class TryBuilderWithForOf extends TryBuilderBase {
         pandaGen.condition(
             (<ts.ForOfStatement>this.stmt).expression,
             ts.SyntaxKind.ExclamationEqualsEqualsToken,
-            getVregisterCache(pandaGen, CacheList.True),
+            getVregisterCache(pandaGen, CacheList.TRUE),
             noReturn);
         // Iterator Close
         pandaGen.loadObjProperty(this.stmt, this.iterator.getObject(), "return");
         pandaGen.storeAccumulator(this.stmt, this.iterator.getNextMethod());
-        pandaGen.condition(this.stmt, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.undefined), noReturn);
+        pandaGen.condition(this.stmt, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(pandaGen, CacheList.UNDEFINED), noReturn);
         pandaGen.call(this.stmt, [this.iterator.getNextMethod(), this.iterator.getObject()], true);
-        if (this.iterator.getType() == IteratorType.Async) {
+        if (this.iterator.getType() === IteratorType.Async) {
             (<AsyncGeneratorFunctionBuilder>(this.compiler.getFuncBuilder())).await(this.stmt);
         }
 
@@ -339,13 +340,13 @@ export class TryBuilderWithForOf extends TryBuilderBase {
         pandaGen.freeTemps(exceptionVreg);
     }
 
-    compileFinalizer(cfc: ControlFlowChange, continueTargetLabel: Label) {
-        if (cfc == ControlFlowChange.Break || continueTargetLabel != this.labelTarget.getContinueTargetLabel()) {
+    compileFinalizer(cfc: ControlFlowChange, continueTargetLabel: Label): void {
+        if (cfc === ControlFlowChange.Break || continueTargetLabel != this.labelTarget.getContinueTargetLabel()) {
             let noReturn = new Label();
             let innerResult = this.pandaGen.getTemp();
             this.pandaGen.loadObjProperty(this.stmt, this.iterator.getObject(), "return");
             this.pandaGen.storeAccumulator(this.stmt, this.iterator.getNextMethod());
-            this.pandaGen.condition(this.stmt, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(this.pandaGen, CacheList.undefined), noReturn);
+            this.pandaGen.condition(this.stmt, ts.SyntaxKind.ExclamationEqualsEqualsToken, getVregisterCache(this.pandaGen, CacheList.UNDEFINED), noReturn);
             this.pandaGen.call(this.stmt, [this.iterator.getNextMethod(), this.iterator.getObject()], true);
 
             this.pandaGen.storeAccumulator(this.stmt, innerResult);
@@ -356,9 +357,9 @@ export class TryBuilderWithForOf extends TryBuilderBase {
         }
     }
 
-    private compileIteratorNext(stmt: ts.ForOfStatement, pandagen: PandaGen, iterator: IteratorRecord, resultObj: VReg) {
+    private compileIteratorNext(stmt: ts.ForOfStatement, pandagen: PandaGen, iterator: IteratorRecord, resultObj: VReg): void {
         pandagen.call(stmt, [iterator.getNextMethod(), iterator.getObject()], true);
-        if (iterator.getType() == IteratorType.Async) {
+        if (iterator.getType() === IteratorType.Async) {
             (<AsyncGeneratorFunctionBuilder>(this.compiler.getFuncBuilder())).await(this.stmt);
         }
         pandagen.storeAccumulator(stmt, resultObj);
@@ -366,13 +367,13 @@ export class TryBuilderWithForOf extends TryBuilderBase {
     }
 }
 
-function compileCatchClauseVariableDeclaration(compiler: Compiler, param: ts.VariableDeclaration | undefined) {
+function compileCatchClauseVariableDeclaration(compiler: Compiler, param: ts.VariableDeclaration | undefined): void {
     if (param) {
         compiler.compileVariableDeclaration(param);
     }
 }
 
-export function updateCatchTables(inlinedTry: TryStatement | undefined, targetTry: TryStatement, inlinedLabelPair: LabelPair) {
+export function updateCatchTables(inlinedTry: TryStatement | undefined, targetTry: TryStatement, inlinedLabelPair: LabelPair): void {
     for (; inlinedTry != targetTry; inlinedTry = inlinedTry?.getOuterTryStatement()) {
         inlinedTry!.getCatchTable().splitLabelPair(inlinedLabelPair);
     }
@@ -382,7 +383,7 @@ export function updateCatchTables(inlinedTry: TryStatement | undefined, targetTr
 export function generateCatchTables(catchMap: Map<Label, CatchTable>): CatchTable[] {
     let catchTableList: CatchTable[] = [];
     catchMap.forEach((catchTable) => {
-        catchTableList.push(catchTable)
+        catchTableList.push(catchTable);
     });
     catchTableList.sort((a, b) => (b.getDepth() - a.getDepth()));
     return catchTableList;
diff --git a/ts2panda/src/strictMode.ts b/ts2panda/src/strictMode.ts
index a3b0bc1e24..89a9912aab 100644
--- a/ts2panda/src/strictMode.ts
+++ b/ts2panda/src/strictMode.ts
@@ -21,12 +21,12 @@ let globalDeclare = false;
 
 export function checkStrictModeStatementList(node: ts.Node): boolean {
     let statements;
-    if (node.kind == ts.SyntaxKind.SourceFile) {
+    if (node.kind === ts.SyntaxKind.SourceFile) {
         statements = (<ts.SourceFile>node).statements;
     } else {
         let decl = <ts.FunctionLikeDeclaration>node;
         if (decl && decl.body) {
-            if (decl.body.kind == ts.SyntaxKind.Block) {
+            if (decl.body.kind === ts.SyntaxKind.Block) {
                 statements = (<ts.Block>decl.body).statements;
             }
         } else {
@@ -34,7 +34,7 @@ export function checkStrictModeStatementList(node: ts.Node): boolean {
         }
     }
 
-    if (statements == undefined) {
+    if (statements === undefined) {
         return false;
     }
 
@@ -80,7 +80,7 @@ function getGlobalStrict(): boolean {
     return globalStrict;
 }
 
-export function setGlobalStrict(flag: boolean) {
+export function setGlobalStrict(flag: boolean): void {
     globalStrict = flag;
 }
 
@@ -92,10 +92,10 @@ export function isStrictMode(node: ts.Node): boolean {
     return checkStrictMode(node);
 }
 
-export function setGlobalDeclare(flag: boolean) {
+export function setGlobalDeclare(flag: boolean): void {
     globalDeclare = flag;
 }
 
-export function isGlobalDeclare() {
+export function isGlobalDeclare(): boolean {
     return globalDeclare;
 }
\ No newline at end of file
diff --git a/ts2panda/src/syntaxCheckHelper.ts b/ts2panda/src/syntaxCheckHelper.ts
index 38a785e6e9..9718e60462 100644
--- a/ts2panda/src/syntaxCheckHelper.ts
+++ b/ts2panda/src/syntaxCheckHelper.ts
@@ -34,7 +34,7 @@ export function isNewOrCallExpression(node: ts.Node): boolean {
     return node.kind === ts.SyntaxKind.NewExpression || node.kind === ts.SyntaxKind.CallExpression;
 }
 
-export function stringLiteralIsInRegExp(node: ts.Node) {
+export function stringLiteralIsInRegExp(node: ts.Node): boolean {
     let parent = node.parent;
     if (parent && isNewOrCallExpression(parent)) {
         let expression = (<ts.NewExpression | ts.CallExpression>parent).expression;
@@ -57,8 +57,8 @@ export function isIncludeOctalEscapeSequence(text: string): boolean {
     // Like \\1, should not be treated as an octal escape sequence
     let index = 0;
     while (index < text.length) {
-        if (text[index] == '\\' && index != text.length - 1) {
-            if (text[index + 1] == "\\") {
+        if (text[index] === '\\' && index != text.length - 1) {
+            if (text[index + 1] === "\\") {
                 index++;
             } else if (text[index + 1] >= '0' && text[index + 1] <= '7') {
                 return true;
@@ -74,7 +74,7 @@ export function isEvalOrArgumentsIdentifier(node: ts.Node): boolean {
     return ts.isIdentifier(node) && (node.escapedText === "eval" || node.escapedText === MandatoryArguments);
 }
 
-export function isLeftHandSideExpressionKind(kind: ts.SyntaxKind) {
+export function isLeftHandSideExpressionKind(kind: ts.SyntaxKind): boolean {
     switch (kind) {
         case ts.SyntaxKind.NumericLiteral:
         case ts.SyntaxKind.BigIntLiteral:
@@ -110,11 +110,11 @@ export function isLeftHandSideExpressionKind(kind: ts.SyntaxKind) {
     }
 }
 
-export function isLeftHandSideExpression(node: ts.Node) {
+export function isLeftHandSideExpression(node: ts.Node): boolean {
     return isLeftHandSideExpressionKind(ts.skipPartiallyEmittedExpressions(node).kind);
 }
 
-export function isAssignmentOperator(token: ts.SyntaxKind) {
+export function isAssignmentOperator(token: ts.SyntaxKind): boolean {
     return token >= ts.SyntaxKind.FirstAssignment && token <= ts.SyntaxKind.LastAssignment;
 }
 
@@ -168,7 +168,7 @@ export function allowLetAndConstDeclarations(node: ts.Node): boolean {
     return true;
 }
 
-export function isGlobalIdentifier(name: string) {
+export function isGlobalIdentifier(name: string): boolean {
     switch (name) {
         case "NaN":
         case "undefined":
@@ -239,10 +239,10 @@ export function isIncludeBackslash8Or9InString(text: string): boolean {
     // \8 and \9 are not allowed in strict mode
     let index = 0;
     while (index < text.length) {
-        if (text[index] == '\\' && index != text.length - 1) {
-            if (text[index + 1] == "\\") {
+        if (text[index] === '\\' && index != text.length - 1) {
+            if (text[index + 1] === "\\") {
                 index++;
-            } else if (text[index + 1] == '8' || text[index + 1] == '9') {
+            } else if (text[index + 1] === '8' || text[index + 1] === '9') {
                 return true;
             }
         }
@@ -269,7 +269,7 @@ export function isOptionalParameter(node: ts.ParameterDeclaration): boolean {
     return false;
 }
 
-export function isStatement(kind: ts.SyntaxKind) {
+export function isStatement(kind: ts.SyntaxKind): boolean {
     if (kind >= ts.SyntaxKind.FirstStatement && kind <= ts.SyntaxKind.LastStatement) {
         return true;
     }
diff --git a/ts2panda/src/syntaxChecker.ts b/ts2panda/src/syntaxChecker.ts
index 69750aa96d..746626684d 100644
--- a/ts2panda/src/syntaxChecker.ts
+++ b/ts2panda/src/syntaxChecker.ts
@@ -56,7 +56,7 @@ import {
 import { MandatoryArguments } from "./variable";
 
 //*************************************Part 1: Implement early check of declarations*******************************//
-export function checkDuplicateDeclaration(recorder: Recorder) {
+export function checkDuplicateDeclaration(recorder: Recorder): void {
     let scopeMap = recorder.getScopeMap();
     scopeMap.forEach((scope, node) => {
         // implement functionParameter-related duplicate-entry check
@@ -75,7 +75,7 @@ export function checkDuplicateDeclaration(recorder: Recorder) {
         }
 
         // implement catchParameter-related duplicate-entry check
-        if ((node.kind == ts.SyntaxKind.Block) && (node.parent != undefined && node.parent.kind == ts.SyntaxKind.CatchClause)) {
+        if ((node.kind === ts.SyntaxKind.Block) && (node.parent != undefined && node.parent.kind === ts.SyntaxKind.CatchClause)) {
             let catchScope = <Scope>scopeMap.get(node.parent);
             checkDuplicateInCatch(scope, catchScope);
         }
@@ -93,7 +93,7 @@ export function checkDuplicateDeclaration(recorder: Recorder) {
     })
 }
 
-function checkDuplicateEntryAcrossScope(scope: Scope, index: number) {
+function checkDuplicateEntryAcrossScope(scope: Scope, index: number): void {
     let decls = scope.getDecls();
     let parentScope: Scope | undefined = scope;
     if (decls[index] instanceof VarDecl) {
@@ -113,7 +113,7 @@ function checkDuplicateEntryAcrossScope(scope: Scope, index: number) {
     }
 }
 
-function checkDuplicateEntryInScope(scope: Scope, index: number) {
+function checkDuplicateEntryInScope(scope: Scope, index: number): void {
     let decls = scope.getDecls();
     for (let i = index + 1; i < decls.length; i++) {
         if (hasDuplicateEntryInScope(decls[index], decls[i], scope)) {
@@ -122,27 +122,27 @@ function checkDuplicateEntryInScope(scope: Scope, index: number) {
     }
 }
 
-function hasDuplicateExportedFuncDecl(decl: FuncDecl, exportFuncMap: Map<string, boolean>) {
+function hasDuplicateExportedFuncDecl(decl: FuncDecl, exportFuncMap: Map<string, boolean>): void {
     if (!exportFuncMap.has(decl.name)) {
         exportFuncMap.set(decl.name, hasExportKeywordModifier(decl.node));
     } else {
-        if (exportFuncMap.get(decl.name) == true || hasExportKeywordModifier(decl.node)) {
+        if (exportFuncMap.get(decl.name) === true || hasExportKeywordModifier(decl.node)) {
             throw new DiagnosticError(decl.node, DiagnosticCode.Duplicate_identifier_0, jshelpers.getSourceFileOfNode(decl.node), [decl.name]);
         }
     }
 }
 
-function hasDuplicateEntryAcrossScope(decl1: Decl, decl2: Decl) {
+function hasDuplicateEntryAcrossScope(decl1: Decl, decl2: Decl): boolean {
     if ((decl2 instanceof LetDecl) || (decl2 instanceof ConstDecl)) {
-        return decl1.name == decl2.name;
+        return decl1.name === decl2.name;
     }
 }
 
-function hasDuplicateEntryInScope(decl1: Decl, decl2: Decl, scope: Scope) {
+function hasDuplicateEntryInScope(decl1: Decl, decl2: Decl, scope: Scope): boolean {
     if (((decl1 instanceof LetDecl) || (decl1 instanceof ConstDecl) || (decl1 instanceof ClassDecl && ts.isClassDeclaration(decl1.node)) ||
         (decl2 instanceof LetDecl) || (decl2 instanceof ConstDecl) || (decl2 instanceof ClassDecl && ts.isClassDeclaration(decl1.node))) &&
         !ts.isClassExpression(decl1.node) && !ts.isClassExpression(decl2.node)) {
-        return decl1.name == decl2.name;
+        return decl1.name === decl2.name;
     }
     // Var and FunctionDeclaration with same names, FunctionDeclaration and FunctionDeclaration with same names are illegal in strict mode
     // and Module
@@ -167,20 +167,20 @@ function hasDuplicateEntryInScope(decl1: Decl, decl2: Decl, scope: Scope) {
             if (isFunctionLikeDeclaration(decl1.node.parent.parent) || isFunctionLikeDeclaration(decl2.node.parent.parent)) {
                 return false;
             }
-            return decl1.name == decl2.name;
+            return decl1.name === decl2.name;
         }
     }
 
     return false;
 }
 
-function checkDuplicateInCatch(blockScope: Scope, catchScope: Scope) {
+function checkDuplicateInCatch(blockScope: Scope, catchScope: Scope): void {
     let bodyDecls = blockScope.getDecls();
     let catchParameters = catchScope.getDecls();
 
     for (let i = 0; i < catchParameters.length; i++) {
         for (let j = i + 1; j < catchParameters.length; j++) {
-            if (catchParameters[i].name == catchParameters[j].name) {
+            if (catchParameters[i].name === catchParameters[j].name) {
                 throwDupIdError(catchParameters[j]);
             }
         }
@@ -190,14 +190,14 @@ function checkDuplicateInCatch(blockScope: Scope, catchScope: Scope) {
                 continue;
             }
 
-            if (catchParameters[i].name == bodyDecls[m].name) {
+            if (catchParameters[i].name === bodyDecls[m].name) {
                 throwDupIdError(bodyDecls[m]);
             }
         }
     }
 }
 
-function getParameterNames(node: ts.FunctionLikeDeclaration, recorder: Recorder) {
+function getParameterNames(node: ts.FunctionLikeDeclaration, recorder: Recorder): string[] {
     let parameters = recorder.getParametersOfFunction(node);
     let parameterNames: string[] = [];
 
@@ -212,7 +212,7 @@ function getParameterNames(node: ts.FunctionLikeDeclaration, recorder: Recorder)
     return parameterNames;
 }
 
-function checkDuplicateParameter(node: ts.FunctionLikeDeclaration, recorder: Recorder) {
+function checkDuplicateParameter(node: ts.FunctionLikeDeclaration, recorder: Recorder): void {
     let parameters = recorder.getParametersOfFunction(node);
     let tempNames: string[] = [];
     if (!parameters) {
@@ -228,7 +228,7 @@ function checkDuplicateParameter(node: ts.FunctionLikeDeclaration, recorder: Rec
     });
 }
 
-function checkDuplicateParameterVar(parameterNames: string[] | undefined, scope: Scope) {
+function checkDuplicateParameterVar(parameterNames: string[] | undefined, scope: Scope): void {
     if (!parameterNames) {
         return;
     }
@@ -245,7 +245,7 @@ function checkDuplicateParameterVar(parameterNames: string[] | undefined, scope:
     }
 }
 
-function checkDeclareGlobalId(decl: Decl, scope: Scope) {
+function checkDeclareGlobalId(decl: Decl, scope: Scope): void {
     if (!(scope instanceof GlobalScope)) {
         return;
     }
@@ -256,27 +256,27 @@ function checkDeclareGlobalId(decl: Decl, scope: Scope) {
 
     if (isGlobalIdentifier(decl.name) && isDeclInGlobal(<ts.Identifier>decl.node)) {
         let sourceNode = jshelpers.getSourceFileOfNode(decl.node);
-        throw new DiagnosticError(decl.node, DiagnosticCode.Declaration_name_conflicts_with_built_in_global_identifier_0, sourceNode, [decl.name])
+        throw new DiagnosticError(decl.node, DiagnosticCode.Declaration_name_conflicts_with_built_in_global_identifier_0, sourceNode, [decl.name]);
     }
 }
 
-function throwDupIdError(decl: Decl) {
+function throwDupIdError(decl: Decl): void {
     let sourceNode = jshelpers.getSourceFileOfNode(decl.node);
-    if (decl.node.kind == ts.SyntaxKind.FunctionDeclaration) {
+    if (decl.node.kind === ts.SyntaxKind.FunctionDeclaration) {
         decl.node = <ts.Identifier>(<ts.FunctionDeclaration>decl.node).name;
     }
     throw new DiagnosticError(decl.node, DiagnosticCode.Duplicate_identifier_0, sourceNode, [decl.name]);
 }
 
 //**********************************Part 2: Implementing syntax check except declaration******************************************//
-export function checkSyntaxError(node: ts.Node, scope:Scope) {
+export function checkSyntaxError(node: ts.Node, scope:Scope): void {
     checkSyntaxErrorForSloppyAndStrictMode(node);
     if (isStrictMode(node) || CmdOptions.isModules()) {
         checkSyntaxErrorForStrictMode(node, scope);
     }
 }
 
-function checkBreakOrContinueStatement(node: ts.BreakOrContinueStatement) {
+function checkBreakOrContinueStatement(node: ts.BreakOrContinueStatement): boolean {
     let curNode: ts.Node = node;
     while (curNode) {
         if (ts.isFunctionLike(curNode)) {
@@ -296,13 +296,14 @@ function checkBreakOrContinueStatement(node: ts.BreakOrContinueStatement) {
                     // found matching label - verify that label usage is correct
                     // continue can only target labels that are on iteration statements
                     let isMisplacedContinueLabel = false;
-                    if (node.kind === ts.SyntaxKind.ContinueStatement
-                        && !jshelpers.isIterationStatement((<ts.LabeledStatement>curNode).statement, /*lookInLabeledStatement*/ true)) {
+                    if (node.kind === ts.SyntaxKind.ContinueStatement &&
+                        !jshelpers.isIterationStatement((<ts.LabeledStatement>curNode).statement, /*lookInLabeledStatement*/ true)) {
                         isMisplacedContinueLabel = true;
                     }
 
                     if (isMisplacedContinueLabel) {
-                        throw new DiagnosticError(node, DiagnosticCode.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement, jshelpers.getSourceFileOfNode(curNode));
+                        throw new DiagnosticError(node, DiagnosticCode.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement,
+                            jshelpers.getSourceFileOfNode(curNode));
                     }
 
                     return;
@@ -324,13 +325,13 @@ function checkBreakOrContinueStatement(node: ts.BreakOrContinueStatement) {
     let diagnosticCode;
 
     if (node.label) {
-        if (node.kind == ts.SyntaxKind.BreakStatement) {
+        if (node.kind === ts.SyntaxKind.BreakStatement) {
             diagnosticCode = DiagnosticCode.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement;
         } else {
             diagnosticCode = DiagnosticCode.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement;
         }
     } else {
-        if (node.kind == ts.SyntaxKind.BreakStatement) {
+        if (node.kind === ts.SyntaxKind.BreakStatement) {
             diagnosticCode = DiagnosticCode.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement;
         } else {
             diagnosticCode = DiagnosticCode.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement;
@@ -340,7 +341,7 @@ function checkBreakOrContinueStatement(node: ts.BreakOrContinueStatement) {
     throw new DiagnosticError(node, diagnosticCode, jshelpers.getSourceFileOfNode(node));
 }
 
-function checkReturnStatement(node: ts.ReturnStatement) {
+function checkReturnStatement(node: ts.ReturnStatement): void {
     let func = jshelpers.getContainingFunction(node);
     if (!func) {
         let file = jshelpers.getSourceFileOfNode(node);
@@ -348,7 +349,7 @@ function checkReturnStatement(node: ts.ReturnStatement) {
     }
 }
 
-function checkMetaProperty(node: ts.MetaProperty) {
+function checkMetaProperty(node: ts.MetaProperty): void {
     let text = jshelpers.getTextOfIdentifierOrLiteral(node.name);
     let file = jshelpers.getSourceFileOfNode(node);
     switch (node.keywordToken) {
@@ -360,13 +361,16 @@ function checkMetaProperty(node: ts.MetaProperty) {
 
             let func = getContainingFunctionDeclaration(node);
             if (!func) {
-                throw new DiagnosticError(node, DiagnosticCode.Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor, file, args);
+                throw new DiagnosticError(node,
+                    DiagnosticCode.Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor, file, args);
             } else {
                 if (ts.isMethodDeclaration(func)) {
-                    throw new DiagnosticError(node, DiagnosticCode.Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor, file, args);
+                    throw new DiagnosticError(node,
+                        DiagnosticCode.Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor, file, args);
                 }
                 if (ts.isArrowFunction(func) && !jshelpers.getNewTargetContainer(node)) {
-                    throw new DiagnosticError(node, DiagnosticCode.Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor, file, args);
+                    throw new DiagnosticError(node,
+                        DiagnosticCode.Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor, file, args);
                 }
             }
             break;
@@ -383,7 +387,7 @@ function checkMetaProperty(node: ts.MetaProperty) {
     }
 }
 
-function checkNameInLetOrConstDeclarations(name: ts.Identifier | ts.BindingPattern) {
+function checkNameInLetOrConstDeclarations(name: ts.Identifier | ts.BindingPattern): void {
     if (name.kind === ts.SyntaxKind.Identifier) {
         if (name.originalKeywordKind === ts.SyntaxKind.LetKeyword) {
             let file = jshelpers.getSourceFileOfNode(name);
@@ -399,7 +403,7 @@ function checkNameInLetOrConstDeclarations(name: ts.Identifier | ts.BindingPatte
     }
 }
 
-function checkDisallowedLetOrConstStatement(node: ts.VariableStatement) {
+function checkDisallowedLetOrConstStatement(node: ts.VariableStatement): void {
     if (allowLetAndConstDeclarations(node.parent)) {
         return;
     }
@@ -413,7 +417,7 @@ function checkDisallowedLetOrConstStatement(node: ts.VariableStatement) {
     }
 }
 
-function checkVariableDeclaration(node: ts.VariableDeclaration) {
+function checkVariableDeclaration(node: ts.VariableDeclaration): void {
     let file = jshelpers.getSourceFileOfNode(node);
     if (!ts.isForInStatement(node.parent.parent) && !ts.isForOfStatement(node.parent.parent) && !ts.isCatchClause(node.parent)) {
         if (!node.initializer) {
@@ -429,24 +433,26 @@ function checkVariableDeclaration(node: ts.VariableDeclaration) {
 
     if (node.exclamationToken && (node.parent.parent.kind !== ts.SyntaxKind.VariableStatement || !node.type || node.initializer)) {
         if (node.initializer) {
-            throw new DiagnosticError(node.exclamationToken, DiagnosticCode.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions, file);
+            throw new DiagnosticError(node.exclamationToken,
+                DiagnosticCode.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions, file);
         } else {
-            throw new DiagnosticError(node.exclamationToken, DiagnosticCode.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations, file);
+            throw new DiagnosticError(node.exclamationToken,
+                DiagnosticCode.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations, file);
         }
     }
 
     if (jshelpers.isLet(node) || jshelpers.isVarConst(node)) {
         checkNameInLetOrConstDeclarations(node.name);
-        if (!isInBlockScope(node.parent.parent.parent)
-            && !ts.isForInStatement(node.parent.parent)
-            && !ts.isForOfStatement(node.parent.parent)
-            && !ts.isForStatement(node.parent.parent)) {
+        if (!isInBlockScope(node.parent.parent.parent) &&
+            !ts.isForInStatement(node.parent.parent) &&
+            !ts.isForOfStatement(node.parent.parent) &&
+            !ts.isForStatement(node.parent.parent)) {
             throw new DiagnosticError(node, DiagnosticCode.const_and_let_declarations_not_allowed_in_statement_positions, file);
         }
     }
 }
 
-function checkDecorators(node: ts.Node) {
+function checkDecorators(node: ts.Node): void {
     if (!node.decorators) {
         return;
     }
@@ -466,7 +472,7 @@ function checkDecorators(node: ts.Node) {
     }
 }
 
-function checkAsyncModifier(node: ts.Node, asyncModifier: ts.Node) {
+function checkAsyncModifier(node: ts.Node, asyncModifier: ts.Node): void {
     switch (node.kind) {
         case ts.SyntaxKind.ArrowFunction:
         case ts.SyntaxKind.FunctionDeclaration:
@@ -477,10 +483,10 @@ function checkAsyncModifier(node: ts.Node, asyncModifier: ts.Node) {
             break;
     }
     let file = jshelpers.getSourceFileOfNode(node);
-    throw new DiagnosticError(asyncModifier, DiagnosticCode._0_modifier_cannot_be_used_here, file, ["async"])
+    throw new DiagnosticError(asyncModifier, DiagnosticCode._0_modifier_cannot_be_used_here, file, ["async"]);
 }
 
-function checkModifiers(node: ts.Node) {
+function checkModifiers(node: ts.Node): void {
     if (!node.modifiers) {
         return;
     }
@@ -495,16 +501,19 @@ function checkModifiers(node: ts.Node) {
     for (let modifier of node.modifiers!) {
         if (modifier.kind !== ts.SyntaxKind.ReadonlyKeyword) {
             if (ts.isPropertySignature(node) || ts.isMethodSignature(node)) {
-                throw new DiagnosticError(modifier, DiagnosticCode._0_modifier_cannot_appear_on_a_type_member, file, [jshelpers.tokenToString(modifier.kind)]);
+                throw new DiagnosticError(modifier, DiagnosticCode._0_modifier_cannot_appear_on_a_type_member,
+                    file, [jshelpers.tokenToString(modifier.kind)]);
             }
             if (ts.isIndexSignatureDeclaration(node)) {
-                throw new DiagnosticError(modifier, DiagnosticCode._0_modifier_cannot_appear_on_an_index_signature, file, [jshelpers.tokenToString(modifier.kind)]);
+                throw new DiagnosticError(modifier, DiagnosticCode._0_modifier_cannot_appear_on_an_index_signature,
+                    file, [jshelpers.tokenToString(modifier.kind)]);
             }
         }
         switch (modifier.kind) {
             case ts.SyntaxKind.ConstKeyword: {
                 if (ts.isEnumDeclaration(node)) {
-                    throw new DiagnosticError(node, DiagnosticCode.A_class_member_cannot_have_the_0_keyword, file, [jshelpers.tokenToString(ts.SyntaxKind.ConstKeyword)]);
+                    throw new DiagnosticError(node, DiagnosticCode.A_class_member_cannot_have_the_0_keyword,
+                        file, [jshelpers.tokenToString(ts.SyntaxKind.ConstKeyword)]);
                 }
                 break;
             }
@@ -558,9 +567,11 @@ function checkModifiers(node: ts.Node) {
             case ts.SyntaxKind.ReadonlyKeyword: {
                 if (flags & ts.ModifierFlags.Readonly) {
                     throw new DiagnosticError(modifier, DiagnosticCode._0_modifier_already_seen, file, ["readonly"]);
-                } else if (!ts.isPropertyDeclaration(node) && !ts.isPropertySignature(node) && !ts.isIndexSignatureDeclaration(node) && !ts.isParameter(node)) {
+                } else if (!ts.isPropertyDeclaration(node) && !ts.isPropertySignature(node) &&
+                           !ts.isIndexSignatureDeclaration(node) && !ts.isParameter(node)) {
                     // If node.kind === SyntaxKind.Parameter, checkParameter report an error if it's not a parameter property.
-                    throw new DiagnosticError(modifier, DiagnosticCode.The_readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature, file);
+                    throw new DiagnosticError(modifier,
+                        DiagnosticCode.The_readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature, file);
                 }
                 flags |= ts.ModifierFlags.Readonly;
                 lastReadonly = modifier;
@@ -613,8 +624,10 @@ function checkModifiers(node: ts.Node) {
                     throw new DiagnosticError(modifier, DiagnosticCode._0_modifier_already_seen, file, ["abstract"]);
                 }
                 if (ts.isClassDeclaration(node) && ts.isConstructorTypeNode(node)) {
-                    if (!ts.isMethodDeclaration(node) && !ts.isPropertyDeclaration(node) && !ts.isGetAccessorDeclaration(node) && !ts.isSetAccessorDeclaration(node)) {
-                        throw new DiagnosticError(modifier, DiagnosticCode.The_abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration, file);
+                    if (!ts.isMethodDeclaration(node) && !ts.isPropertyDeclaration(node) &&
+                        !ts.isGetAccessorDeclaration(node) && !ts.isSetAccessorDeclaration(node)) {
+                        throw new DiagnosticError(modifier,
+                            DiagnosticCode.The_abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration, file);
                     }
                     if (flags & ts.ModifierFlags.Static) {
                         throw new DiagnosticError(modifier, DiagnosticCode._0_modifier_cannot_be_used_with_1_modifier, file, ["static", "abstract"]);
@@ -678,7 +691,7 @@ function checkModifiers(node: ts.Node) {
     }
 }
 
-function checkVariableDeclarationList(declarationList: ts.VariableDeclarationList) {
+function checkVariableDeclarationList(declarationList: ts.VariableDeclarationList): void {
     let declarations = declarationList.declarations;
     if (!declarations.length) {
         throw new DiagnosticError(declarationList, DiagnosticCode.Identifier_expected);
@@ -690,14 +703,14 @@ function checkVariableDeclarationList(declarationList: ts.VariableDeclarationLis
     }
 }
 
-function checkVariableStatement(node: ts.VariableStatement) {
+function checkVariableStatement(node: ts.VariableStatement): void {
     checkDecorators(node);
     checkModifiers(node);
     checkVariableDeclarationList(node.declarationList);
     checkDisallowedLetOrConstStatement(node);
 }
 
-function checkForInOrForOfStatement(stmt: ts.ForInOrOfStatement) {
+function checkForInOrForOfStatement(stmt: ts.ForInOrOfStatement): void {
     let file = jshelpers.getSourceFileOfNode(stmt);
     let leftExpr = stmt.initializer;
     if (ts.isParenthesizedExpression(leftExpr)) {
@@ -710,25 +723,31 @@ function checkForInOrForOfStatement(stmt: ts.ForInOrOfStatement) {
 
         if (declarations.length > 1) {
             if (ts.isForInStatement(stmt)) {
-                throw new DiagnosticError(variableList.declarations[1], DiagnosticCode.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement, file);
+                throw new DiagnosticError(variableList.declarations[1],
+                    DiagnosticCode.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement, file);
             } else {
-                throw new DiagnosticError(variableList.declarations[1], DiagnosticCode.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement, file);
+                throw new DiagnosticError(variableList.declarations[1],
+                    DiagnosticCode.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement, file);
             }
         }
 
         if (declarations[0].initializer) {
             if (ts.isForInStatement(stmt)) {
-                throw new DiagnosticError(declarations[0].name, DiagnosticCode.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer, file);
+                throw new DiagnosticError(declarations[0].name,
+                    DiagnosticCode.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer, file);
             } else {
-                throw new DiagnosticError(declarations[0].name, DiagnosticCode.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer, file);
+                throw new DiagnosticError(declarations[0].name,
+                    DiagnosticCode.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer, file);
             }
         }
 
         if (declarations[0].type) {
             if (ts.isForInStatement(stmt)) {
-                throw new DiagnosticError(declarations[0], DiagnosticCode.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation, file);
+                throw new DiagnosticError(declarations[0],
+                    DiagnosticCode.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation, file);
             } else {
-                throw new DiagnosticError(declarations[0], DiagnosticCode.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation, file);
+                throw new DiagnosticError(declarations[0],
+                    DiagnosticCode.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation, file);
             }
         }
     } else {
@@ -740,7 +759,7 @@ function checkForInOrForOfStatement(stmt: ts.ForInOrOfStatement) {
     }
 }
 
-function checkForInOrForOfVariableDeclaration(iterationStatement: ts.ForInOrOfStatement) {
+function checkForInOrForOfVariableDeclaration(iterationStatement: ts.ForInOrOfStatement): void {
     let variableDeclarationList = <ts.VariableDeclarationList>iterationStatement.initializer;
     // checkGrammarForInOrForOfStatement will check that there is exactly one declaration.
     if (variableDeclarationList.declarations.length >= 1) {
@@ -748,7 +767,7 @@ function checkForInOrForOfVariableDeclaration(iterationStatement: ts.ForInOrOfSt
     }
 }
 
-function checkForInStatement(node: ts.ForInStatement) {
+function checkForInStatement(node: ts.ForInStatement): void {
     checkForInOrForOfStatement(node);
 
     let file = jshelpers.getSourceFileOfNode(node);
@@ -764,17 +783,18 @@ function checkForInStatement(node: ts.ForInStatement) {
 }
 
 const enum OuterExpressionKinds {
-    Parentheses = 1 << 0,
-    TypeAssertions = 1 << 1,
-    NonNullAssertions = 1 << 2,
-    PartiallyEmittedExpressions = 1 << 3,
-    Assertions = TypeAssertions | NonNullAssertions,
-    All = Parentheses | Assertions | PartiallyEmittedExpressions
+    PARENTHESES = 1 << 0,
+    TYPEASSERTIONS = 1 << 1,
+    NON_NULL_ASSERTIONS= 1 << 2,
+    PARTIALLY_EMITTED_EXPRESSIONS = 1 << 3,
+    ASSERTIONS= TYPEASSERTIONS | NON_NULL_ASSERTIONS,
+    ALL = PARENTHESES | ASSERTIONS | PARTIALLY_EMITTED_EXPRESSIONS
 }
 
-function checkReferenceExpression(expr: ts.Expression, invalidReferenceCode: DiagnosticCode, invalidOptionalChainCode: DiagnosticCode) {
-    let node = jshelpers.skipOuterExpressions(expr, OuterExpressionKinds.Assertions | OuterExpressionKinds.Parentheses);
-    if (node.kind !== ts.SyntaxKind.Identifier && node.kind !== ts.SyntaxKind.PropertyAccessExpression && node.kind !== ts.SyntaxKind.ElementAccessExpression) {
+function checkReferenceExpression(expr: ts.Expression, invalidReferenceCode: DiagnosticCode, invalidOptionalChainCode: DiagnosticCode): void {
+    let node = jshelpers.skipOuterExpressions(expr, OuterExpressionKinds.ASSERTIONS | OuterExpressionKinds.PARENTHESES);
+    if (node.kind !== ts.SyntaxKind.Identifier && node.kind !== ts.SyntaxKind.PropertyAccessExpression &&
+        node.kind !== ts.SyntaxKind.ElementAccessExpression) {
         throw new DiagnosticError(expr, invalidReferenceCode);
     }
 
@@ -783,7 +803,7 @@ function checkReferenceExpression(expr: ts.Expression, invalidReferenceCode: Dia
     }
 }
 
-function checkReferenceAssignment(node: ts.Expression) {
+function checkReferenceAssignment(node: ts.Expression): void {
     let invalidReferenceCode: DiagnosticCode;
     let invalidOptionalChainCode: DiagnosticCode;
 
@@ -798,7 +818,7 @@ function checkReferenceAssignment(node: ts.Expression) {
     checkReferenceExpression(node, invalidReferenceCode, invalidOptionalChainCode);
 }
 
-function checkDestructuringAssignment(node: ts.Expression | ts.ShorthandPropertyAssignment) {
+function checkDestructuringAssignment(node: ts.Expression | ts.ShorthandPropertyAssignment): void {
     let target: ts.Expression;
     if (ts.isShorthandPropertyAssignment(node)) {
         let prop = <ts.ShorthandPropertyAssignment>node;
@@ -820,7 +840,7 @@ function checkDestructuringAssignment(node: ts.Expression | ts.ShorthandProperty
 
 }
 
-function checkForOfStatement(node: ts.ForOfStatement) {
+function checkForOfStatement(node: ts.ForOfStatement): void {
     checkForInOrForOfStatement(node);
 
     if (ts.isVariableDeclarationList(node.initializer)) {
@@ -839,7 +859,7 @@ function checkForOfStatement(node: ts.ForOfStatement) {
     }
 }
 
-function checkClassDeclaration(node: ts.ClassLikeDeclaration) {
+function checkClassDeclaration(node: ts.ClassLikeDeclaration): void {
     checkClassDeclarationHeritageClauses(node);
     let hasConstructorImplementation = false;
     let file = jshelpers.getSourceFileOfNode(node);
@@ -872,17 +892,17 @@ function checkClassDeclaration(node: ts.ClassLikeDeclaration) {
 
 }
 
-function checkClassDeclarationHeritageClauses(node: ts.ClassLikeDeclaration) {
+function checkClassDeclarationHeritageClauses(node: ts.ClassLikeDeclaration): void {
     let hasExtendsKeyWords = false;
     checkDecorators(node);
     checkModifiers(node);
-    if (node.heritageClauses == undefined) {
+    if (node.heritageClauses === undefined) {
         return;
     }
 
     let file = jshelpers.getSourceFileOfNode(node);
     for (let heritageClause of node.heritageClauses) {
-        if (heritageClause.token == ts.SyntaxKind.ExtendsKeyword) {
+        if (heritageClause.token === ts.SyntaxKind.ExtendsKeyword) {
             if (hasExtendsKeyWords) {
                 throw new DiagnosticError(heritageClause, DiagnosticCode.The_extends_clause_already_seen, file);
             }
@@ -895,7 +915,7 @@ function checkClassDeclarationHeritageClauses(node: ts.ClassLikeDeclaration) {
     }
 }
 
-function checkBinaryExpression(node: ts.BinaryExpression) {
+function checkBinaryExpression(node: ts.BinaryExpression): void {
     // AssignmentExpression
     if (isAssignmentOperator(node.operatorToken.kind)) {
         let leftExpr: ts.Expression = node.left;
@@ -903,7 +923,7 @@ function checkBinaryExpression(node: ts.BinaryExpression) {
             leftExpr = findInnerExprOfParenthesis(leftExpr);
         }
 
-        if (node.operatorToken.kind == ts.SyntaxKind.EqualsToken) {
+        if (node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
             if (ts.isArrayLiteralExpression(leftExpr) || ts.isObjectLiteralExpression(leftExpr)) {
                 checkDestructuringAssignmentLhs(leftExpr);
             }
@@ -913,16 +933,16 @@ function checkBinaryExpression(node: ts.BinaryExpression) {
     }
 }
 
-function isInVaildAssignmentLeftSide(leftExpr: ts.Expression) {
-    if (jshelpers.isKeyword(leftExpr.kind)
-        || leftExpr.kind == ts.SyntaxKind.NumericLiteral
-        || leftExpr.kind == ts.SyntaxKind.StringLiteral) {
+function isInVaildAssignmentLeftSide(leftExpr: ts.Expression): void {
+    if (jshelpers.isKeyword(leftExpr.kind) ||
+        leftExpr.kind === ts.SyntaxKind.NumericLiteral ||
+        leftExpr.kind === ts.SyntaxKind.StringLiteral) {
         throw new DiagnosticError(leftExpr, DiagnosticCode.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access);
     }
 }
 
 
-function checkContextualIdentifier(node: ts.Identifier) {
+function checkContextualIdentifier(node: ts.Identifier): void {
     if (jshelpers.isIdentifierName(node)) {
         return;
     }
@@ -930,16 +950,19 @@ function checkContextualIdentifier(node: ts.Identifier) {
     let file = jshelpers.getSourceFileOfNode(node);
     if (node.originalKeywordKind === ts.SyntaxKind.AwaitKeyword) {
         if (jshelpers.isExternalOrCommonJsModule(file) && jshelpers.isInTopLevelContext(node)) {
-            throw new DiagnosticError(node, DiagnosticCode.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module, file, jshelpers.declarationNameToString(node));
+            throw new DiagnosticError(node, DiagnosticCode.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module,
+                file, jshelpers.declarationNameToString(node));
         } else if (node.flags & ts.NodeFlags.AwaitContext) {
-            throw new DiagnosticError(node, DiagnosticCode.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here, file, jshelpers.declarationNameToString(node));
+            throw new DiagnosticError(node, DiagnosticCode.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here,
+                file, jshelpers.declarationNameToString(node));
         }
     } else if (node.originalKeywordKind === ts.SyntaxKind.YieldKeyword && node.flags & ts.NodeFlags.YieldContext) {
-        throw new DiagnosticError(node, DiagnosticCode.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here, file, jshelpers.declarationNameToString(node));
+        throw new DiagnosticError(node, DiagnosticCode.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here,
+            file, jshelpers.declarationNameToString(node));
     }
 }
 
-function checkComputedPropertyName(node: ts.Node) {
+function checkComputedPropertyName(node: ts.Node): void {
     if (!ts.isComputedPropertyName(node)) {
         return;
     }
@@ -952,15 +975,15 @@ function checkComputedPropertyName(node: ts.Node) {
 }
 
 const enum DeclarationMeaning {
-    GetAccessor = 1,
-    SetAccessor = 2,
-    PropertyAssignment = 4,
-    Method = 8,
-    GetOrSetAccessor = GetAccessor | SetAccessor,
-    PropertyAssignmentOrMethod = PropertyAssignment | Method,
+    GET_ACCESSOR = 1,
+    SET_ACCESSOR = 2,
+    PROPERTY_ASSIGNMENT = 4,
+    METHOD= 8,
+    GET_OR_SET_ACCESSOR = GET_ACCESSOR | SET_ACCESSOR,
+    PROPERTY_ASSIGNMENT_OR_METHOD = PROPERTY_ASSIGNMENT | METHOD,
 }
 
-function checkObjectLiteralExpression(node: ts.ObjectLiteralExpression) {
+function checkObjectLiteralExpression(node: ts.ObjectLiteralExpression): void {
     let inDestructuring = jshelpers.isAssignmentTarget(node);
     let file = jshelpers.getSourceFileOfNode(node);
     let seen = new Map<ts.__String, DeclarationMeaning>();
@@ -981,7 +1004,9 @@ function checkObjectLiteralExpression(node: ts.ObjectLiteralExpression) {
         }
 
         if (ts.isShorthandPropertyAssignment(prop) && !inDestructuring && prop.objectAssignmentInitializer) {
-            throw new DiagnosticError(prop.equalsToken!, DiagnosticCode.Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern, file);
+            throw new DiagnosticError(prop.equalsToken!,
+                DiagnosticCode.Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern,
+                file);
         }
 
         if (ts.isPrivateIdentifier(name)) {
@@ -1002,15 +1027,19 @@ function checkObjectLiteralExpression(node: ts.ObjectLiteralExpression) {
         * PropertyDefinition : PropertyName : AssignmentExpression .
         */
         let curKind = getPropertieDeclaration(prop, name);
-        if (!curKind) continue;
+        if (!curKind) {
+            continue;
+        } 
         if (!inDestructuring) {
             let effectName = jshelpers.getPropertyNameForPropertyNameNode(name);
-            if (!effectName || ts.isComputedPropertyName(name)) continue;
+            if (!effectName || ts.isComputedPropertyName(name)) {
+                continue;
+            }
             let existKind = seen.get(effectName);
             if (!existKind) {
                 seen.set(effectName, curKind);
             } else {
-                if ((curKind & DeclarationMeaning.PropertyAssignmentOrMethod) && (existKind & DeclarationMeaning.PropertyAssignmentOrMethod)) {
+                if ((curKind & DeclarationMeaning.PROPERTY_ASSIGNMENT_OR_METHOD) && (existKind & DeclarationMeaning.PROPERTY_ASSIGNMENT_OR_METHOD)) {
                     if (effectName === "___proto__") {
                         throw new DiagnosticError(name, DiagnosticCode.Duplicate_identifier_0, file, [jshelpers.getTextOfNode(name)]);
                     }
@@ -1020,14 +1049,14 @@ function checkObjectLiteralExpression(node: ts.ObjectLiteralExpression) {
     }
 }
 
-function checkInvalidExclamationToken(exclamationToken: ts.ExclamationToken | undefined) {
+function checkInvalidExclamationToken(exclamationToken: ts.ExclamationToken | undefined): void {
     if (!!exclamationToken) {
         let file = jshelpers.getSourceFileOfNode(exclamationToken);
         throw new DiagnosticError(exclamationToken, DiagnosticCode.A_definite_assignment_assertion_is_not_permitted_in_this_context, file);
     }
 }
 
-function checkInvalidQuestionMark(questionToken: ts.QuestionToken | undefined) {
+function checkInvalidQuestionMark(questionToken: ts.QuestionToken | undefined): void {
     if (!!questionToken) {
         let file = jshelpers.getSourceFileOfNode(questionToken);
         throw new DiagnosticError(questionToken, DiagnosticCode.An_object_member_cannot_be_declared_optional, file);
@@ -1035,34 +1064,34 @@ function checkInvalidQuestionMark(questionToken: ts.QuestionToken | undefined) {
 }
 
 // @ts-ignore
-function getPropertieDeclaration(node: ts.Node, name: ts.Node) {
+function getPropertieDeclaration(node: ts.Node, name: ts.Node): any {
     let decl = undefined;
     if (ts.isShorthandPropertyAssignment(node)) {
         checkInvalidExclamationToken(node.exclamationToken);
     } else if (ts.isPropertyAssignment(node)) {
         checkInvalidQuestionMark(node.questionToken);
-        decl = DeclarationMeaning.PropertyAssignment;
+        decl = DeclarationMeaning.PROPERTY_ASSIGNMENT;
     } else if (ts.isMethodDeclaration(node)) {
-        decl = DeclarationMeaning.Method;
+        decl = DeclarationMeaning.METHOD;
     } else if (ts.isGetAccessor(node)) {
         checkGetAccessor(node);
-        decl = DeclarationMeaning.GetAccessor;
+        decl = DeclarationMeaning.GET_ACCESSOR;
     } else if (ts.isSetAccessor(node)) {
-        decl = DeclarationMeaning.SetAccessor;
+        decl = DeclarationMeaning.SET_ACCESSOR;
     } else {
         LOGE("Unexpected syntax kind:" + node.kind);
     }
     return decl;
 }
 
-function checkDisallowedTrailingComma(list: ts.NodeArray<ts.Node> | undefined) {
+function checkDisallowedTrailingComma(list: ts.NodeArray<ts.Node> | undefined): void {
     if (list && list.hasTrailingComma) {
         let file = jshelpers.getSourceFileOfNode(list[0]);
         throw new DiagnosticError(list[0], DiagnosticCode.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma, file);
     }
 }
 
-function checkParameters(parameters: ts.NodeArray<ts.ParameterDeclaration>) {
+function checkParameters(parameters: ts.NodeArray<ts.ParameterDeclaration>): void {
     let count = parameters.length;
     let optionalParameter = false;
 
@@ -1096,7 +1125,7 @@ function checkParameters(parameters: ts.NodeArray<ts.ParameterDeclaration>) {
     }
 }
 
-function checkArrowFunction(node: ts.Node) {
+function checkArrowFunction(node: ts.Node): void {
     if (!ts.isArrowFunction(node)) {
         return;
     }
@@ -1110,14 +1139,14 @@ function checkArrowFunction(node: ts.Node) {
     }
 }
 
-function checkFunctionLikeDeclaration(node: ts.FunctionLikeDeclaration | ts.MethodSignature) {
+function checkFunctionLikeDeclaration(node: ts.FunctionLikeDeclaration | ts.MethodSignature): void {
     checkDecorators(node);
     checkModifiers(node);
     checkParameters(node.parameters);
     checkArrowFunction(node);
 }
 
-function checkLabeledStatement(node: ts.LabeledStatement) {
+function checkLabeledStatement(node: ts.LabeledStatement): void {
     let file = jshelpers.getSourceFileOfNode(node);
     jshelpers.findAncestor(node.parent, current => {
         if (jshelpers.isFunctionLike(current)) {
@@ -1143,7 +1172,7 @@ function checkLabeledStatement(node: ts.LabeledStatement) {
     }
 }
 
-function checkGetAccessor(node: ts.GetAccessorDeclaration) {
+function checkGetAccessor(node: ts.GetAccessorDeclaration): void {
     checkFunctionLikeDeclaration(node);
     if (node.parameters.length != 0) {
         throw new DiagnosticError(node, DiagnosticCode.Getter_must_not_have_any_formal_parameters);
@@ -1167,7 +1196,7 @@ function isValidUseSuperExpression(node: ts.Node, isCallExpression: boolean): bo
         ts.isPropertyDeclaration(node) || ts.isPropertySignature(node) || ts.isConstructorDeclaration(node);
 }
 
-function checkSuperExpression(node: ts.SuperExpression) {
+function checkSuperExpression(node: ts.SuperExpression): void {
     let file = jshelpers.getSourceFileOfNode(node);
     let isCallExpression = false;
     if (ts.isCallExpression(node.parent) && (<ts.CallExpression>node.parent).expression === node) {
@@ -1194,18 +1223,21 @@ function checkSuperExpression(node: ts.SuperExpression) {
             return;
         }
         if (isCallExpression) {
-            throw new DiagnosticError(node, DiagnosticCode.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors, file);
+            throw new DiagnosticError(node,
+                DiagnosticCode.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors, file);
         }
 
         if (!container || !container.parent || !ts.isClassLike(container.parent) || ts.isObjectLiteralExpression(container.parent)) {
-            throw new DiagnosticError(node, DiagnosticCode.The_super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions, file);
+            throw new DiagnosticError(node,
+                DiagnosticCode.The_super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions, file);
         }
 
-        throw new DiagnosticError(node, DiagnosticCode.The_super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class, file);
+        throw new DiagnosticError(node,
+            DiagnosticCode.The_super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class, file);
     }
 }
 
-function checkImportExpression(node: ts.ImportExpression) {
+function checkImportExpression(node: ts.ImportExpression): void {
     let args = (<ts.CallExpression>node.parent).arguments;
     if (args.length != 1) {
         throw new DiagnosticError(node, DiagnosticCode.Dynamic_imports_can_only_accept_a_module_specifier_optional_assertion_is_not_supported_yet);
@@ -1218,19 +1250,19 @@ function checkImportExpression(node: ts.ImportExpression) {
     });
 }
 
-function checkRegularExpression(regexp: ts.RegularExpressionLiteral) {
+function checkRegularExpression(regexp: ts.RegularExpressionLiteral): void {
     let regexpText = regexp.text;
     let regexpParse = require("regexpp").RegExpParser;
     new regexpParse().parseLiteral(regexpText);
 }
 
-function checkThrowStatement(node: ts.ThrowStatement) {
+function checkThrowStatement(node: ts.ThrowStatement): void {
     if (ts.isIdentifier(node.expression) && (<ts.Identifier>node.expression).text === '') {
         throw new DiagnosticError(node, DiagnosticCode.Line_break_not_permitted_here, jshelpers.getSourceFileOfNode(node));
     }
 }
 
-function checkSyntaxErrorForSloppyAndStrictMode(node: ts.Node) {
+function checkSyntaxErrorForSloppyAndStrictMode(node: ts.Node): void {
     switch (node.kind) {
         case ts.SyntaxKind.BreakStatement:
         case ts.SyntaxKind.ContinueStatement:
@@ -1306,7 +1338,7 @@ function checkSyntaxErrorForSloppyAndStrictMode(node: ts.Node) {
     }
 }
 
-function checkDestructuringAssignmentLhs(lhs: ts.Expression) {
+function checkDestructuringAssignmentLhs(lhs: ts.Expression): void {
     let file = getSourceFileOfNode(lhs);
     if (ts.isArrayLiteralExpression(lhs)) {
         let elements = lhs.elements;
@@ -1339,7 +1371,7 @@ function checkDestructuringAssignmentLhs(lhs: ts.Expression) {
             if (ts.isIdentifier(target)) {
                 let name = jshelpers.getTextOfIdentifierOrLiteral(target);
 
-                if (name == MandatoryArguments || name == "eval") {
+                if (name === MandatoryArguments || name === "eval") {
                     throw new DiagnosticError(target, DiagnosticCode.Property_destructuring_pattern_expected, file);
                 }
                 continue;
@@ -1402,7 +1434,7 @@ function checkDestructuringAssignmentLhs(lhs: ts.Expression) {
             if (ts.isShorthandPropertyAssignment(element)) {
                 let name = jshelpers.getTextOfIdentifierOrLiteral(element.name);
 
-                if (name == MandatoryArguments || name == "eval") {
+                if (name === MandatoryArguments || name === "eval") {
                     throw new DiagnosticError(element, DiagnosticCode.Property_destructuring_pattern_expected, file);
                 }
 
@@ -1418,7 +1450,7 @@ function checkDestructuringAssignmentLhs(lhs: ts.Expression) {
     }
 }
 
-function checkBindingPattern(node: ts.BindingPattern) {
+function checkBindingPattern(node: ts.BindingPattern): void {
     let elements = node.elements;
 
     for (let i = 0; i < elements.length; i++) {
diff --git a/ts2panda/src/syntaxCheckerForStrcitMode.ts b/ts2panda/src/syntaxCheckerForStrcitMode.ts
index 5747aadad8..ca861b41ed 100644
--- a/ts2panda/src/syntaxCheckerForStrcitMode.ts
+++ b/ts2panda/src/syntaxCheckerForStrcitMode.ts
@@ -32,14 +32,14 @@ import {
     stringLiteralIsInRegExp
 } from "./syntaxCheckHelper";
 
-function checkDeleteStatement(node: ts.DeleteExpression) {
+function checkDeleteStatement(node: ts.DeleteExpression): void {
     let unaryExpr = node.expression;
     if (ts.isIdentifier(unaryExpr)) {
         throw new DiagnosticError(unaryExpr, DiagnosticCode.A_delete_cannot_be_called_on_an_identifier_in_strict_mode);
     }
 }
 
-function checkNumericLiteral(node: ts.NumericLiteral) {
+function checkNumericLiteral(node: ts.NumericLiteral): void {
     let num = jshelpers.getTextOfNode(node);
     if (!isOctalNumber(num)) {
         return;
@@ -48,7 +48,7 @@ function checkNumericLiteral(node: ts.NumericLiteral) {
     throw new DiagnosticError(node, DiagnosticCode.Octal_literals_are_not_allowed_in_strict_mode);
 }
 
-function checkString(node: ts.Node, text: string) {
+function checkString(node: ts.Node, text: string): void {
 
     if (isIncludeOctalEscapeSequence(text)) {
         throw new DiagnosticError(node, DiagnosticCode.Octal_escape_sequences_are_not_allowed_in_strict_mode);
@@ -59,7 +59,7 @@ function checkString(node: ts.Node, text: string) {
     }
 }
 
-function checkStringLiteral(node: ts.StringLiteral) {
+function checkStringLiteral(node: ts.StringLiteral): void {
     // Octal escape has been deprecated in ES5, but it can be used in regular expressions
     if (stringLiteralIsInRegExp(node)) {
         return;
@@ -69,7 +69,7 @@ function checkStringLiteral(node: ts.StringLiteral) {
     checkString(node, text);
 }
 
-function checkEvalOrArgumentsOrOriginalKeyword(contextNode: ts.Node, name: ts.Node | undefined) {
+function checkEvalOrArgumentsOrOriginalKeyword(contextNode: ts.Node, name: ts.Node | undefined): void {
     if (!name || !ts.isIdentifier(name)) {
         return;
     }
@@ -85,7 +85,7 @@ function checkEvalOrArgumentsOrOriginalKeyword(contextNode: ts.Node, name: ts.No
 }
 
 
-function getStrictModeEvalOrArgumentsDiagnosticCode(node: ts.Node) {
+function getStrictModeEvalOrArgumentsDiagnosticCode(node: ts.Node): any {
     if (jshelpers.getContainingClass(node)) {
         return DiagnosticCode.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode;
     }
@@ -93,7 +93,7 @@ function getStrictModeEvalOrArgumentsDiagnosticCode(node: ts.Node) {
     return DiagnosticCode.Invalid_use_of_0_in_strict_mode;
 }
 
-function getStrictModeIdentifierDiagnosticCode(node: ts.Node) {
+function getStrictModeIdentifierDiagnosticCode(node: ts.Node): any {
     if (jshelpers.getContainingClass(node)) {
         return DiagnosticCode.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode;
     }
@@ -101,7 +101,7 @@ function getStrictModeIdentifierDiagnosticCode(node: ts.Node) {
     return DiagnosticCode.Identifier_expected_0_is_a_reserved_word_in_strict_mode;
 }
 
-function checkBinaryExpression(node: ts.BinaryExpression) {
+function checkBinaryExpression(node: ts.BinaryExpression): void {
     if (!isLeftHandSideExpression(node.left) || !isAssignmentOperator(node.operatorToken.kind)) {
         return;
     }
@@ -122,9 +122,9 @@ function checkBinaryExpression(node: ts.BinaryExpression) {
     checkEvalOrArgumentsOrOriginalKeyword(contextNode, <ts.Identifier>name);
 }
 
-function checkContextualIdentifier(node: ts.Identifier) {
+function checkContextualIdentifier(node: ts.Identifier): void {
     let file = jshelpers.getSourceFileOfNode(node);
-    if (jshelpers.getTextOfIdentifierOrLiteral(node) == 'await' && CmdOptions.isModules()) {
+    if (jshelpers.getTextOfIdentifierOrLiteral(node) === 'await' && CmdOptions.isModules()) {
         throw new DiagnosticError(node, DiagnosticCode.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module, file, ['await']);
     }
 
@@ -138,7 +138,7 @@ function checkContextualIdentifier(node: ts.Identifier) {
 
 }
 
-function checkParameters(decl: ts.FunctionLikeDeclaration | ts.FunctionExpression) {
+function checkParameters(decl: ts.FunctionLikeDeclaration | ts.FunctionExpression): void {
     let parameters: ts.NodeArray<ts.ParameterDeclaration> = decl.parameters;
     let obj = new Map();
     for (let i = 0; i < parameters.length; i++) {
@@ -162,17 +162,17 @@ function checkParameters(decl: ts.FunctionLikeDeclaration | ts.FunctionExpressio
     }
 }
 
-function checkWithStatement(node: ts.WithStatement) {
+function checkWithStatement(node: ts.WithStatement): void {
     let file = jshelpers.getSourceFileOfNode(node);
     throw new DiagnosticError(node, DiagnosticCode.A_with_statements_are_not_allowed_in_strict_mode, file);
 }
 
-function checkNoSubstitutionTemplateLiteral(expr: ts.NoSubstitutionTemplateLiteral) {
+function checkNoSubstitutionTemplateLiteral(expr: ts.NoSubstitutionTemplateLiteral): void {
     let text = jshelpers.getTextOfNode(expr);
     checkString(expr, text.substring(1, text.length - 1));
 }
 
-function checkFunctionDeclaration(node: ts.FunctionDeclaration) {
+function checkFunctionDeclaration(node: ts.FunctionDeclaration): void {
     checkEvalOrArgumentsOrOriginalKeyword(node, node.name);
     checkParameters(node);
     if (!isInBlockScope(node.parent!)) {
@@ -180,7 +180,7 @@ function checkFunctionDeclaration(node: ts.FunctionDeclaration) {
     }
 }
 
-function checkClassDeclaration(node: ts.ClassDeclaration) {
+function checkClassDeclaration(node: ts.ClassDeclaration): void {
     if (!hasExportKeywordModifier(node) && !node.name) {
         if (!node.name && !hasDefaultKeywordModifier(node)) {
             throw new DiagnosticError(node, DiagnosticCode.Identifier_expected);
@@ -188,7 +188,7 @@ function checkClassDeclaration(node: ts.ClassDeclaration) {
     }
 }
 
-function checkImportDeclaration(node: ts.ImportDeclaration, scope: Scope) {
+function checkImportDeclaration(node: ts.ImportDeclaration, scope: Scope): void {
     if (!(scope instanceof ModuleScope)) {
         throw new DiagnosticError(node, DiagnosticCode.An_import_declaration_can_only_be_used_in_a_namespace_or_module);
     }
@@ -201,8 +201,8 @@ function checkImportDeclaration(node: ts.ImportDeclaration, scope: Scope) {
         let namedBindings = node.importClause.namedBindings;
         if (ts.isNamedImports(namedBindings)) {
             namedBindings.elements.forEach((element: any) => {
-                if (jshelpers.getTextOfIdentifierOrLiteral(element.name) == 'arguments'
-                    || jshelpers.getTextOfIdentifierOrLiteral(element.name) == 'eval') {
+                if (jshelpers.getTextOfIdentifierOrLiteral(element.name) === 'arguments' ||
+                    jshelpers.getTextOfIdentifierOrLiteral(element.name) === 'eval') {
                     throw new DiagnosticError(node, DiagnosticCode.Unexpected_eval_or_arguments_in_strict_mode);
                 }
             });
@@ -210,7 +210,7 @@ function checkImportDeclaration(node: ts.ImportDeclaration, scope: Scope) {
     }
 }
 
-function checkExportAssignment(node: ts.ExportAssignment, scope: Scope) {
+function checkExportAssignment(node: ts.ExportAssignment, scope: Scope): void {
     if (!(scope instanceof ModuleScope)) {
         throw new DiagnosticError(node, DiagnosticCode.An_export_assignment_must_be_at_the_top_level_of_a_file_or_module_declaration);
     }
@@ -220,7 +220,7 @@ function checkExportAssignment(node: ts.ExportAssignment, scope: Scope) {
     }
 }
 
-function checkExportDeclaration(node: ts.ExportDeclaration, scope: Scope) {
+function checkExportDeclaration(node: ts.ExportDeclaration, scope: Scope): void {
     if (!(scope instanceof ModuleScope)) {
         throw new DiagnosticError(node, DiagnosticCode.An_export_declaration_can_only_be_used_in_a_module);
     }
@@ -230,7 +230,7 @@ function checkExportDeclaration(node: ts.ExportDeclaration, scope: Scope) {
     }
 }
 
-export function checkSyntaxErrorForStrictMode(node: ts.Node, scope: Scope) {
+export function checkSyntaxErrorForStrictMode(node: ts.Node, scope: Scope): void {
     switch (node.kind) {
         case ts.SyntaxKind.NumericLiteral:
             checkNumericLiteral(<ts.NumericLiteral>node);
diff --git a/ts2panda/src/ts2panda.ts b/ts2panda/src/ts2panda.ts
index ebd5130d63..4d0aed108a 100644
--- a/ts2panda/src/ts2panda.ts
+++ b/ts2panda/src/ts2panda.ts
@@ -65,7 +65,7 @@ import { getLiteralKey } from "./base/util";
 const dollarSign: RegExp = /\$/g;
 const starSign: RegExp = /\*/g;
 
-const JsonType = {
+const jsonType = {
     "function": 0,
     "record": 1,
     "string": 2,
@@ -90,7 +90,7 @@ export class Ts2Panda {
         return new Signature(pg.getParametersCount());
     }
 
-    static getFuncInsnsAndRegsNum(pg: PandaGen) {
+    static getFuncInsnsAndRegsNum(pg: PandaGen): { insns: Ins[]; regsNum: number; labels: string[]; } {
         let insns: Array<Ins> = [];
         let labels: Array<string> = [];
 
@@ -150,13 +150,13 @@ export class Ts2Panda {
                 });
             }
 
-            insn.debugPosInfo.ClearNodeKind();
+            insn.debugPosInfo.clearNodeKind();
 
             insns.push(new Ins(
                 insOpcode,
-                insRegs.length == 0 ? undefined : insRegs,
-                insIds.length == 0 ? undefined : insIds,
-                insImms.length == 0 ? undefined : insImms,
+                insRegs.length === 0 ? undefined : insRegs,
+                insIds.length === 0 ? undefined : insIds,
+                insImms.length === 0 ? undefined : insImms,
                 insLabel === "" ? undefined : insLabel,
                 insn.debugPosInfo,
             ));
@@ -165,7 +165,7 @@ export class Ts2Panda {
         return {
             insns: insns,
             regsNum: (pg.getTotalRegsNum() - pg.getParametersCount()),
-            labels: labels.length == 0 ? undefined : labels
+            labels: labels.length === 0 ? undefined : labels
         };
     }
 
@@ -187,7 +187,7 @@ export class Ts2Panda {
         let strings_arr = Array.from(Ts2Panda.strings);
 
         let strObject = {
-            "t": JsonType.string,
+            "t": jsonType.string,
             "s": strings_arr
         }
 
@@ -200,10 +200,10 @@ export class Ts2Panda {
         ts2abc.stdio[3].write(jsonStrUnicode + '\n');
     }
 
-    static dumpTypeLiteralArrayBuffer() {
+    static dumpTypeLiteralArrayBuffer(): string {
         let literalArrays = PandaGen.getLiteralArrayBuffer();
         let countType: LiteralBuffer = literalArrays[0];
-        let jsonTypeString: string = ""
+        let jsonTypeString: string = "";
         let typeCount = countType.getLiteral(0)?.getValue();
         if (typeCount) {
             for (let i = 0; i < typeCount; i++) {
@@ -225,7 +225,7 @@ export class Ts2Panda {
 
         literalArrays.forEach(function(literalArray) {
             let literalArrayObject = {
-                "t": JsonType.literal_arr,
+                "t": jsonType.literal_arr,
                 "lit_arr": literalArray
             }
             let jsonLiteralArrUnicode = escapeUnicode(JSON.stringify(literalArrayObject, null, 2));
@@ -241,7 +241,7 @@ export class Ts2Panda {
     static dumpCmdOptions(ts2abc: any): void {
         let enableRecordType: boolean = CmdOptions.needRecordType() && CompilerDriver.isTsFile;
         let options = {
-            "t": JsonType.options,
+            "t": jsonType.options,
             "merge_abc": CmdOptions.isMergeAbc(),
             "module_mode": CmdOptions.isModules(),
             "commonjs_module": CmdOptions.isCommonJs(),
@@ -266,7 +266,7 @@ export class Ts2Panda {
 
     static dumpRecord(ts2abc: any, recordName: string): void {
         let record = {
-            "t": JsonType.record,
+            "t": jsonType.record,
             "rb": new Record(recordName),
             "pn": CmdOptions.getPackageName()
         }
@@ -298,7 +298,7 @@ export class Ts2Panda {
             }
 
             // get builtin type for tryloadglobal instruction
-            if (inst.kind == IRNodeKind.TRYLDGLOBALBYNAME) {
+            if (inst.kind === IRNodeKind.TRYLDGLOBALBYNAME) {
                 let name = inst.operands[1] as string;
                 if (name in BuiltinType) {
                     typeIdx = BuiltinType[name];
@@ -308,7 +308,7 @@ export class Ts2Panda {
             }
 
             // skip arg type
-            if (i < paraCount && inst.kind == IRNodeKind.MOV) {
+            if (i < paraCount && inst.kind === IRNodeKind.MOV) {
                 let vreg = (inst.operands[0] as VReg).num;
                 let arg = (inst.operands[1] as VReg).num;
                 if (vreg >= paraCount || arg < vregCount) {
@@ -320,7 +320,7 @@ export class Ts2Panda {
             }
 
             // local vreg -> inst
-            if (inst.kind == IRNodeKind.STA) {
+            if (inst.kind === IRNodeKind.STA) {
                 let vreg = (inst.operands[0] as VReg).num;
                 if (vreg < locals.length && !handledSet.has(vreg)) {
                     typeIdx = locals[vreg].getTypeIndex();
@@ -414,7 +414,8 @@ export class Ts2Panda {
             );
         }
 
-        let variables = undefined, sourceCode = undefined;
+        let variables = undefined;
+        let sourceCode = undefined;
         if (CmdOptions.needRecordSourceCode() || CmdOptions.isDebugMode()) {
             // function's sourceCode will be undefined in debugMode
             // if we don't need to record function-sourceCode
@@ -464,7 +465,7 @@ export class Ts2Panda {
         LOGD(func);
 
         let funcObject = {
-            "t": JsonType.function,
+            "t": jsonType.function,
             "fb": func
         }
         let jsonFuncUnicode = escapeUnicode(JSON.stringify(funcObject, null, 2));
@@ -479,7 +480,7 @@ export class Ts2Panda {
     static dumpModuleRecords(ts2abc: any): void {
         Ts2Panda.moduleRecordlist.forEach(function(module){
             let moduleObject = {
-                "t": JsonType.module,
+                "t": jsonType.module,
                 "mod": module
             };
             let jsonModuleUnicode = escapeUnicode(JSON.stringify(moduleObject, null, 2));
@@ -503,7 +504,7 @@ export class Ts2Panda {
             'tsi': typeSummaryIndex
         }
         let typeInfoObject = {
-            't': JsonType.type_info,
+            't': jsonType.type_info,
             'ti': typeInfo
         };
         let jsonTypeInfoUnicode = escapeUnicode(JSON.stringify(typeInfoObject, null, 2));
@@ -517,7 +518,7 @@ export class Ts2Panda {
 
     static dumpInputJsonFileContent(ts2abc: any, inputJsonFileContent: string): void {
         let inputJsonFileContentObject = {
-            "t": JsonType.input_json_file_content,
+            "t": jsonType.input_json_file_content,
             "ijfc": inputJsonFileContent
         }
 
@@ -532,7 +533,7 @@ export class Ts2Panda {
 
     static dumpOutputFileName(ts2abc: any, outputFileName: string): void {
         let outputFileNameObject = {
-            "t": JsonType.output_filename,
+            "t": jsonType.output_filename,
             "ofn": outputFileName
         }
 
@@ -547,7 +548,7 @@ export class Ts2Panda {
         ts2abc.stdio[3].write("*" + '\n');
     }
 
-    static clearDumpData() {
+    static clearDumpData(): void {
         Ts2Panda.strings.clear();
         Ts2Panda.jsonString = "";
         Ts2Panda.moduleRecordlist = [];
diff --git a/ts2panda/src/typeChecker.ts b/ts2panda/src/typeChecker.ts
index 85764ad230..ea455e8684 100644
--- a/ts2panda/src/typeChecker.ts
+++ b/ts2panda/src/typeChecker.ts
@@ -47,7 +47,7 @@ export class TypeChecker {
         return TypeChecker.instance;
     }
 
-    public setTypeChecker(typeChecker: ts.TypeChecker) {
+    public setTypeChecker(typeChecker: ts.TypeChecker): void {
         this.compiledTypeChecker = typeChecker;
     }
 
@@ -55,7 +55,7 @@ export class TypeChecker {
         return this.compiledTypeChecker;
     }
 
-    public getTypeAtLocation(node: ts.Node) {
+    public getTypeAtLocation(node: ts.Node): any {
         if (!node) {
             return undefined;
         }
@@ -67,7 +67,7 @@ export class TypeChecker {
         }
     }
 
-    public getTypeDeclForIdentifier(node: ts.Node) {
+    public getTypeDeclForIdentifier(node: ts.Node): any {
         if (!node) {
             return undefined;
         }
@@ -106,14 +106,14 @@ export class TypeChecker {
         return false;
     }
 
-    public getDeclNodeForInitializer(initializer: ts.Node) {
+    public getDeclNodeForInitializer(initializer: ts.Node): any {
         switch (initializer.kind) {
             case ts.SyntaxKind.Identifier:
                 return this.getTypeDeclForIdentifier(initializer);
             case ts.SyntaxKind.NewExpression:
                 let initializerExpression = <ts.NewExpression>initializer;
                 let expression = initializerExpression.expression;
-                if (expression.kind == ts.SyntaxKind.ClassExpression) {
+                if (expression.kind === ts.SyntaxKind.ClassExpression) {
                     return expression;
                 }
                 return this.getTypeDeclForIdentifier(expression);
@@ -131,7 +131,7 @@ export class TypeChecker {
             return PrimitiveType.ANY;
         }
         let classTypeIndex = TypeRecorder.getInstance().tryGetTypeIndex(typeDeclNode);
-        if (classTypeIndex == PrimitiveType.ANY) {
+        if (classTypeIndex === PrimitiveType.ANY) {
             let classDeclNode = <ts.ClassDeclaration>typeDeclNode;
             let className = "";
             let classNameNode = classDeclNode.name;
@@ -147,25 +147,25 @@ export class TypeChecker {
         return classTypeIndex;
     }
 
-    public getTypeForPropertyAccessExpression(typeDeclNode: ts.Node) {
+    public getTypeForPropertyAccessExpression(typeDeclNode: ts.Node): number {
         let propertyAccessExpression = <ts.PropertyAccessExpression>typeDeclNode;
         let localName = jshelpers.getTextOfIdentifierOrLiteral(propertyAccessExpression.expression);
         let externalName = jshelpers.getTextOfIdentifierOrLiteral(propertyAccessExpression.name);
         if (TypeRecorder.getInstance().inNampespaceMap(localName)) {
             let redirectPath = TypeRecorder.getInstance().getPathForNamespace(localName)!;
             let externalType = new ExternalType(externalName, redirectPath);
-            let ImportTypeIndex = externalType.shiftedTypeIndex;
-            return ImportTypeIndex;
+            let importTypeIndex = externalType.shiftedTypeIndex;
+            return importTypeIndex;
         }
         return PrimitiveType.ANY;
     }
 
-    public getInterfaceDeclaration(typeDeclNode: ts.Node) {
+    public getInterfaceDeclaration(typeDeclNode: ts.Node): number {
         if (this.isFromDefaultLib(typeDeclNode)) {
             return PrimitiveType.ANY;
         }
         let interfaceTypeIndex = TypeRecorder.getInstance().tryGetTypeIndex(typeDeclNode);
-        if (interfaceTypeIndex == PrimitiveType.ANY) {
+        if (interfaceTypeIndex === PrimitiveType.ANY) {
             let interefaceType = new InterfaceType(<ts.InterfaceDeclaration>typeDeclNode);
             interfaceTypeIndex = interefaceType.shiftedTypeIndex;
         }
@@ -183,9 +183,9 @@ export class TypeChecker {
                 return this.getTypeForClassDeclOrExp(typeDeclNode, getTypeForInstace);
             case ts.SyntaxKind.ImportSpecifier:
             case ts.SyntaxKind.ImportClause:
-                let ImportTypeIndex = TypeRecorder.getInstance().tryGetTypeIndex(typeDeclNode);
-                if (ImportTypeIndex != PrimitiveType.ANY) {
-                    return ImportTypeIndex;
+                let importTypeIndex = TypeRecorder.getInstance().tryGetTypeIndex(typeDeclNode);
+                if (importTypeIndex != PrimitiveType.ANY) {
+                    return importTypeIndex;
                 }
                 return PrimitiveType.ANY;
             case ts.SyntaxKind.PropertyAccessExpression:
@@ -197,7 +197,7 @@ export class TypeChecker {
         }
     }
 
-    public getTypeForLiteralTypeNode(node: ts.Node) {
+    public getTypeForLiteralTypeNode(node: ts.Node): PrimitiveType.ANY | PrimitiveType.NUMBER | PrimitiveType.BOOLEAN | PrimitiveType.STRING | PrimitiveType.NULL {
         switch (node.kind) {
             case ts.SyntaxKind.NumericLiteral:
                 return PrimitiveType.NUMBER;
@@ -213,7 +213,7 @@ export class TypeChecker {
         }
     }
 
-    public getTypeFromAnotation(typeNode: ts.TypeNode | undefined) {
+    public getTypeFromAnotation(typeNode: ts.TypeNode | undefined): any {
         if (!typeNode) {
             return PrimitiveType.ANY;
         }
@@ -240,8 +240,8 @@ export class TypeChecker {
                 let arrayType = new ArrayType(typeNode);
                 return arrayType.shiftedTypeIndex;
             case ts.SyntaxKind.ParenthesizedType:
-                let subType = (<ts.ParenthesizedTypeNode>typeNode).type
-                if (subType.kind == ts.SyntaxKind.UnionType) {
+                let subType = (<ts.ParenthesizedTypeNode>typeNode).type;
+                if (subType.kind === ts.SyntaxKind.UnionType) {
                     let unionType = new UnionType(subType);
                     return unionType.shiftedTypeIndex;
                 }
@@ -254,7 +254,7 @@ export class TypeChecker {
                 let typeIdentifierName = jshelpers.getTextOfIdentifierOrLiteral(typeIdentifier);
                 if (BuiltinType[typeIdentifierName]) {
                     let declNode = this.getDeclNodeForInitializer(typeIdentifier);
-                    if (declNode && (ts.isClassLike(declNode) || declNode.kind == ts.SyntaxKind.InterfaceDeclaration)) {
+                    if (declNode && (ts.isClassLike(declNode) || declNode.kind === ts.SyntaxKind.InterfaceDeclaration)) {
                         return this.getBuiltinTypeIndex(<ts.TypeReferenceNode>typeNode, typeIdentifierName);
                     } else {
                         return BuiltinType[typeIdentifierName];
@@ -265,16 +265,16 @@ export class TypeChecker {
         }
     }
 
-    isBuiltinType(expr: ts.NewExpression) {
+    isBuiltinType(expr: ts.NewExpression): boolean {
         let name = expr.expression.getFullText().replace(/\s/g, "");
         return name in BuiltinType;
     }
 
-    isFromDefaultLib(node: ts.Node) {
+    isFromDefaultLib(node: ts.Node): boolean {
         return node.getSourceFile().hasNoDefaultLib;
     }
 
-    getOrCreateInstanceType(classTypeIdx: number) {
+    getOrCreateInstanceType(classTypeIdx: number): number {
         let typeRec = TypeRecorder.getInstance();
         if (typeRec.hasClass2InstanceMap(classTypeIdx)) {
             return typeRec.getClass2InstanceMap(classTypeIdx);
@@ -283,7 +283,7 @@ export class TypeChecker {
         return instanceType.shiftedTypeIndex;
     }
 
-    getOrCreateInstanceTypeForBuiltinContainer(builtinContainerSignature: object) {
+    getOrCreateInstanceTypeForBuiltinContainer(builtinContainerSignature: object): number {
         let typeRec = TypeRecorder.getInstance();
         if (typeRec.hasBuiltinContainer2InstanceMap(builtinContainerSignature)) {
             return typeRec.getBuiltinContainer2InstanceMap(builtinContainerSignature);
@@ -293,7 +293,7 @@ export class TypeChecker {
         return this.getOrCreateInstanceType(builtinContainerTypeIdx);
     }
 
-    getBuiltinTypeIndex(node: ts.NewExpression | ts.TypeReferenceNode, name: string) {
+    getBuiltinTypeIndex(node: ts.NewExpression | ts.TypeReferenceNode, name: string): number {
         let typeArguments = node.typeArguments;
         if (typeArguments && this.needRecordBuiltinContainer) {
             let typeArgIdxs = new Array<number>();
@@ -310,23 +310,23 @@ export class TypeChecker {
         return this.getOrCreateInstanceType(BuiltinType[name]);
     }
 
-    getBuiltinTypeIndexForExpr(expr: ts.NewExpression) {
+    getBuiltinTypeIndexForExpr(expr: ts.NewExpression): number {
         let origExprNode = <ts.NewExpression>ts.getOriginalNode(expr);
         let name = origExprNode.expression.getFullText().replace(/\s/g, "");
         return this.getBuiltinTypeIndex(origExprNode, name);
     }
 
-    public getOrCreateRecordForDeclNode(initializer: ts.Node | undefined, variableNode?: ts.Node) {
+    public getOrCreateRecordForDeclNode(initializer: ts.Node | undefined, variableNode?: ts.Node): PrimitiveType {
         if (!initializer) {
             return PrimitiveType.ANY;
         }
 
         let typeIndex = PrimitiveType.ANY;
-        if (initializer.kind == ts.SyntaxKind.NewExpression && this.isBuiltinType(<ts.NewExpression>initializer)) {
+        if (initializer.kind === ts.SyntaxKind.NewExpression && this.isBuiltinType(<ts.NewExpression>initializer)) {
             typeIndex = this.getBuiltinTypeIndexForExpr(<ts.NewExpression>initializer);
         } else {
             let declNode = this.getDeclNodeForInitializer(initializer);
-            typeIndex = this.getTypeFromDecl(declNode, initializer.kind == ts.SyntaxKind.NewExpression);
+            typeIndex = this.getTypeFromDecl(declNode, initializer.kind === ts.SyntaxKind.NewExpression);
         }
 
         if (variableNode) {
@@ -335,13 +335,13 @@ export class TypeChecker {
         return typeIndex;
     }
 
-    public getOrCreateRecordForTypeNode(typeNode: ts.TypeNode | undefined, variableNode?: ts.Node) {
+    public getOrCreateRecordForTypeNode(typeNode: ts.TypeNode | undefined, variableNode?: ts.Node): PrimitiveType {
         if (!typeNode) {
             return PrimitiveType.ANY;
         }
         let typeIndex = PrimitiveType.ANY;
         typeIndex = this.getTypeFromAnotation(typeNode);
-        if (typeIndex == PrimitiveType.ANY && typeNode.kind == ts.SyntaxKind.TypeReference) {
+        if (typeIndex === PrimitiveType.ANY && typeNode.kind === ts.SyntaxKind.TypeReference) {
             let typeName = typeNode.getChildAt(0);
             let typeDecl = this.getDeclNodeForInitializer(typeName);
             typeIndex = this.getTypeFromDecl(typeDecl, true);
@@ -352,14 +352,14 @@ export class TypeChecker {
         return typeIndex;
     }
 
-    public formatVariableStatement(variableStatementNode: ts.VariableStatement) {
+    public formatVariableStatement(variableStatementNode: ts.VariableStatement): void {
         let decList = variableStatementNode.declarationList;
         decList.declarations.forEach(declaration => {
             let variableNode = declaration.name;
             let typeNode = declaration.type;
             let initializer = declaration.initializer;
             let typeIndex = this.getOrCreateRecordForTypeNode(typeNode, variableNode);
-            if (typeIndex == PrimitiveType.ANY) {
+            if (typeIndex === PrimitiveType.ANY) {
                 typeIndex = this.getOrCreateRecordForDeclNode(initializer, variableNode);
             }
             if (this.hasExportKeyword(variableStatementNode) && typeIndex != PrimitiveType.ANY) {
@@ -369,7 +369,7 @@ export class TypeChecker {
         });
     }
 
-    public formatClassDeclaration(classDeclNode: ts.ClassDeclaration) {
+    public formatClassDeclaration(classDeclNode: ts.ClassDeclaration): void {
         if (this.isFromDefaultLib(classDeclNode)) {
             return;
         }
@@ -380,7 +380,7 @@ export class TypeChecker {
         }
 
         let typeIndex = TypeRecorder.getInstance().tryGetTypeIndex(classDeclNode);
-        if (typeIndex == PrimitiveType.ANY) {
+        if (typeIndex === PrimitiveType.ANY) {
             let classType = new ClassType(classDeclNode, BuiltinType[className]);
             typeIndex = classType.shiftedTypeIndex;
         }
@@ -393,14 +393,14 @@ export class TypeChecker {
     }
 
     // Entry for type recording
-    public formatNodeType(node: ts.Node, importOrExportStmt?: ModuleStmt) {
+    public formatNodeType(node: ts.Node, importOrExportStmt?: ModuleStmt): void {
         if (this.compiledTypeChecker === null) {
             return;
         }
         switch (node.kind) {
             case ts.SyntaxKind.VariableStatement:
                 let variableStatementNode = <ts.VariableStatement>ts.getOriginalNode(node);
-                if (variableStatementNode.kind == ts.SyntaxKind.VariableStatement) {
+                if (variableStatementNode.kind === ts.SyntaxKind.VariableStatement) {
                     this.formatVariableStatement(variableStatementNode);
                 }
                 break;
@@ -411,7 +411,7 @@ export class TypeChecker {
                 }
                 let functionName = functionDeclNode.name ? functionDeclNode.name : undefined;
                 let funcTypeIndex = TypeRecorder.getInstance().tryGetTypeIndex(functionDeclNode);
-                if (funcTypeIndex == PrimitiveType.ANY) {
+                if (funcTypeIndex === PrimitiveType.ANY) {
                     let functionnameText = "";
                     if (functionName) {
                         functionnameText = jshelpers.getTextOfIdentifierOrLiteral(functionName);
diff --git a/ts2panda/src/typeRecorder.ts b/ts2panda/src/typeRecorder.ts
index a760ffc08c..5eff409a26 100644
--- a/ts2panda/src/typeRecorder.ts
+++ b/ts2panda/src/typeRecorder.ts
@@ -50,15 +50,15 @@ export class TypeRecorder {
         return TypeRecorder.instance;
     }
 
-    public setTypeSummary() {
+    public setTypeSummary(): void {
         this.typeSummary.setInfo(this.countUserDefinedTypeSet(), this.anonymousReExport);
     }
 
-    public getTypeSummaryIndex() {
+    public getTypeSummaryIndex(): number {
         return this.typeSummary.getPreservedIndex();
     }
 
-    public addUserDefinedTypeSet(index: number) {
+    public addUserDefinedTypeSet(index: number): void {
         if (index > userDefinedTypeStartIndex) {
             this.userDefinedTypeSet.add(index);
         }
@@ -68,12 +68,12 @@ export class TypeRecorder {
         return this.userDefinedTypeSet.size;
     }
 
-    public addType2Index(typeNode: ts.Node, index: number) {
+    public addType2Index(typeNode: ts.Node, index: number): void {
         this.type2Index.set(typeNode, index);
         this.addUserDefinedTypeSet(index);
     }
 
-    public setVariable2Type(variableNode: ts.Node, index: number) {
+    public setVariable2Type(variableNode: ts.Node, index: number): void {
         this.variable2Type.set(variableNode, index);
         this.addUserDefinedTypeSet(index);
     }
@@ -98,56 +98,56 @@ export class TypeRecorder {
         }
     }
 
-    public setArrayTypeMap(contentTypeIndex: number, arrayTypeIndex: number) {
-        this.arrayTypeMap.set(contentTypeIndex, arrayTypeIndex)
+    public setArrayTypeMap(contentTypeIndex: number, arrayTypeIndex: number): void {
+        this.arrayTypeMap.set(contentTypeIndex, arrayTypeIndex);
     }
 
-    public hasArrayTypeMapping(contentTypeIndex: number) {
+    public hasArrayTypeMapping(contentTypeIndex: number): boolean {
         return this.arrayTypeMap.has(contentTypeIndex);
     }
 
-    public getFromArrayTypeMap(contentTypeIndex: number) {
+    public getFromArrayTypeMap(contentTypeIndex: number): number {
         return this.arrayTypeMap.get(contentTypeIndex);
     }
 
-    public setUnionTypeMap(unionStr: string, unionTypeIndex: number) {
+    public setUnionTypeMap(unionStr: string, unionTypeIndex: number): void {
         this.unionTypeMap.set(unionStr, unionTypeIndex)
     }
 
-    public hasUnionTypeMapping(unionStr: string) {
+    public hasUnionTypeMapping(unionStr: string): boolean {
         return this.unionTypeMap.has(unionStr);
     }
 
-    public getFromUnionTypeMap(unionStr: string) {
+    public getFromUnionTypeMap(unionStr: string): number {
         return this.unionTypeMap.get(unionStr);
     }
 
-    public setClass2InstanceMap(classIndex: number, instanceIndex: number) {
-        this.class2InstanceMap.set(classIndex, instanceIndex)
+    public setClass2InstanceMap(classIndex: number, instanceIndex: number): void {
+        this.class2InstanceMap.set(classIndex, instanceIndex);
     }
 
-    public hasClass2InstanceMap(classIndex: number) {
+    public hasClass2InstanceMap(classIndex: number): boolean {
         return this.class2InstanceMap.has(classIndex);
     }
 
-    public getClass2InstanceMap(classIndex: number) {
+    public getClass2InstanceMap(classIndex: number): number {
         return this.class2InstanceMap.get(classIndex);
     }
 
-    public setBuiltinContainer2InstanceMap(builtinContainer: object, instanceIndex: number) {
-        this.builtinContainer2InstanceMap.set(builtinContainer, instanceIndex)
+    public setBuiltinContainer2InstanceMap(builtinContainer: object, instanceIndex: number): void {
+        this.builtinContainer2InstanceMap.set(builtinContainer, instanceIndex);
     }
 
-    public hasBuiltinContainer2InstanceMap(builtinContainer: object) {
+    public hasBuiltinContainer2InstanceMap(builtinContainer: object): boolean {
         return this.builtinContainer2InstanceMap.has(builtinContainer);
     }
 
-    public getBuiltinContainer2InstanceMap(builtinContainer: object) {
+    public getBuiltinContainer2InstanceMap(builtinContainer: object): number {
         return this.builtinContainer2InstanceMap.get(builtinContainer);
     }
 
     // exported/imported
-    public addImportedType(moduleStmt: ModuleStmt) {
+    public addImportedType(moduleStmt: ModuleStmt): void {
         moduleStmt.getBindingNodeMap().forEach((externalNode, localNode) => {
             let externalName = jshelpers.getTextOfIdentifierOrLiteral(externalNode);
             let importDeclNode = TypeChecker.getInstance().getTypeDeclForIdentifier(localNode);
@@ -159,12 +159,12 @@ export class TypeRecorder {
         if (moduleStmt.getNameSpace() != "") {
             this.setNamespaceMap(moduleStmt.getNameSpace(), moduleStmt.getModuleRequest());
             let externalType = new ExternalType("*", moduleStmt.getNameSpace());
-            let ImportTypeIndex = externalType.shiftedTypeIndex;
-            this.addUserDefinedTypeSet(ImportTypeIndex);
+            let importTypeIndex = externalType.shiftedTypeIndex;
+            this.addUserDefinedTypeSet(importTypeIndex);
         }
     }
 
-    public addExportedType(moduleStmt: ModuleStmt) {
+    public addExportedType(moduleStmt: ModuleStmt): void {
         if (moduleStmt.getModuleRequest() != "") {
             // re-export, no need to search in typeRecord cause it must not be there
             if (moduleStmt.getNameSpace() != "") {
@@ -198,7 +198,7 @@ export class TypeRecorder {
         }
     }
 
-    public addNonReExportedType(exportedName: string, typeNode: ts.Node, localNode: ts.Node) {
+    public addNonReExportedType(exportedName: string, typeNode: ts.Node, localNode: ts.Node): void {
         // Check if type of localName was already stroed in typeRecord
         // Imported type should already be stored in typeRecord by design
         let typeIndexForType = this.tryGetTypeIndex(typeNode);
@@ -210,32 +210,32 @@ export class TypeRecorder {
         } else {
             // not found in typeRecord. Need to create the type and
             // add to typeRecord with its localName and to exportedType with its exportedName
-            let typeIndex = TypeChecker.getInstance().getTypeFromDecl(typeNode, localNode.kind == ts.SyntaxKind.NewExpression);
+            let typeIndex = TypeChecker.getInstance().getTypeFromDecl(typeNode, localNode.kind === ts.SyntaxKind.NewExpression);
             this.setExportedType(exportedName, typeIndex);
         }
     }
 
-    public setExportedType(exportedName: string, typeIndex: number) {
+    public setExportedType(exportedName: string, typeIndex: number): void {
         this.exportedType.set(exportedName, typeIndex);
     }
 
-    public setDeclaredType(exportedName: string, typeIndex: number) {
+    public setDeclaredType(exportedName: string, typeIndex: number): void {
         this.declaredType.set(exportedName, typeIndex);
     }
 
-    public addAnonymousReExport(redirectName: string) {
+    public addAnonymousReExport(redirectName: string): void {
         this.anonymousReExport.push(redirectName);
     }
 
-    public setNamespaceMap(namespace: string, filePath: string) {
+    public setNamespaceMap(namespace: string, filePath: string): void {
         this.namespaceMap.set(namespace, filePath);
     }
 
-    public inNampespaceMap(targetName: string) {
+    public inNampespaceMap(targetName: string): boolean {
         return this.namespaceMap.has(targetName);
     }
 
-    public getPathForNamespace(targetName: string) {
+    public getPathForNamespace(targetName: string): string {
         return this.namespaceMap.get(targetName);
     }
 
@@ -248,39 +248,39 @@ export class TypeRecorder {
         return this.variable2Type;
     }
 
-    public getTypeSet() {
+    public getTypeSet(): Set<number> {
         return this.userDefinedTypeSet;
     }
 
-    public getExportedType() {
+    public getExportedType(): Map<string, number> {
         return this.exportedType;
     }
 
-    public getDeclaredType() {
+    public getDeclaredType(): Map<string, number> {
         return this.declaredType;
     }
 
-    public getAnonymousReExport() {
+    public getAnonymousReExport(): string[] {
         return this.anonymousReExport;
     }
 
-    public getNamespaceMap() {
+    public getNamespaceMap(): Map<string, string> {
         return this.namespaceMap;
     }
 
-    public printNodeMap(map: Map<ts.Node, number>) {
+    public printNodeMap(map: Map<ts.Node, number>): void {
         map.forEach((value, key) => {
             console.log(jshelpers.getTextOfNode(key) + ": " + value);
         });
     }
 
-    public printExportMap(map: Map<string, number>) {
+    public printExportMap(map: Map<string, number>): void {
         map.forEach((value, key) => {
             console.log(key + " : " + value);
         });
     }
 
-    public printReExportMap(map: Map<string, string>) {
+    public printReExportMap(map: Map<string, string>): void {
         map.forEach((value, key) => {
             console.log(key + " : " + value);
         });
diff --git a/ts2panda/src/variable.ts b/ts2panda/src/variable.ts
index 4f51d0af8b..aebf8f8d77 100644
--- a/ts2panda/src/variable.ts
+++ b/ts2panda/src/variable.ts
@@ -44,7 +44,7 @@ export abstract class Variable {
         this.typeIndex = 0;
     }
 
-    bindVreg(vreg: VReg) {
+    bindVreg(vreg: VReg): void {
         this.vreg = vreg;
         this.vreg.setTypeIndex(this.typeIndex);
         this.vreg.setVariableName(this.name);
@@ -56,35 +56,35 @@ export abstract class Variable {
 
     getVreg(): VReg {
         if (!this.vreg) {
-            throw new Error("variable has not been binded")
+            throw new Error("variable has not been binded");
         }
         return this.vreg;
     }
 
-    getName() {
+    getName(): string {
         return this.name;
     }
 
-    getTypeIndex() {
+    getTypeIndex(): number {
         return this.typeIndex;
     }
 
-    setTypeIndex(typeIndex: number) {
+    setTypeIndex(typeIndex: number): number {
         return this.typeIndex = typeIndex;
     }
 
-    setLexVar(scope: VariableScope | LoopScope) {
+    setLexVar(scope: VariableScope | LoopScope): number {
         if (this.lexical()) {
             return;
         }
-        this.idxLex = scope.getLexVarIdx()
+        this.idxLex = scope.getLexVarIdx();
         scope.pendingCreateEnv();
         this.isLexVar = true;
         scope.addLexVarInfo(this.name, this.idxLex);
         return this.idxLex;
     }
 
-    clearLexVar() {
+    clearLexVar(): void {
         this.isLexVar = false;
         this.idxLex = 0;
     }
@@ -93,32 +93,32 @@ export abstract class Variable {
         return this.isLexVar;
     }
 
-    lexIndex() {
+    lexIndex(): number {
         return this.idxLex;
     }
 
     isLet(): boolean {
-        return this.declKind == VarDeclarationKind.LET;
+        return this.declKind === VarDeclarationKind.LET;
     }
 
     isConst(): boolean {
-        return this.declKind == VarDeclarationKind.CONST;
+        return this.declKind === VarDeclarationKind.CONST;
     }
 
     isLetOrConst(): boolean {
-        return this.declKind == VarDeclarationKind.LET || this.declKind == VarDeclarationKind.CONST;
+        return this.declKind === VarDeclarationKind.LET || this.declKind === VarDeclarationKind.CONST;
     }
 
     isVar(): boolean {
-        return this.declKind == VarDeclarationKind.VAR;
+        return this.declKind === VarDeclarationKind.VAR;
     }
 
     isNone(): boolean {
-        return this.declKind == VarDeclarationKind.NONE;
+        return this.declKind === VarDeclarationKind.NONE;
     }
 
     isClass(): boolean {
-        return this.declKind == VarDeclarationKind.CLASS;
+        return this.declKind === VarDeclarationKind.CLASS;
     }
 }
 
@@ -130,13 +130,13 @@ export class LocalVariable extends Variable {
         this.status = status ? status : null;
     }
 
-    initialize() {
+    initialize(): void {
         this.status = InitStatus.INITIALIZED;
     }
 
-    isInitialized() {
+    isInitialized(): boolean {
         if (this.status != null) {
-            return this.status == InitStatus.INITIALIZED;
+            return this.status === InitStatus.INITIALIZED;
         }
         return true;
     }
@@ -153,30 +153,30 @@ export class ModuleVariable extends Variable {
         this.status = status ? status : null;
     }
 
-    initialize() {
+    initialize(): void {
         this.status = InitStatus.INITIALIZED;
     }
 
-    isInitialized() {
+    isInitialized(): boolean {
         if (this.status != null) {
-            return this.status == InitStatus.INITIALIZED;
+            return this.status === InitStatus.INITIALIZED;
         }
         return true;
     }
 
-    setExport() {
+    setExport(): void {
         this.isExport = true;
     }
 
-    isExportVar() {
+    isExportVar(): boolean {
         return this.isExport;
     }
 
-    assignIndex(index: number) {
+    assignIndex(index: number): void {
         this.index = index;
     }
 
-    getIndex() {
+    getIndex(): number {
         return this.index;
     }
 }
@@ -192,9 +192,9 @@ export const MandatoryNewTarget = "4newTarget";
 export const MandatoryThis = "this";
 export const MandatoryArguments = "arguments";
 
-export function isMandatoryParam(name: string) {
-    if (name == MandatoryFuncObj || name == MandatoryArguments ||
-        name == MandatoryNewTarget || name == MandatoryThis) {
+export function isMandatoryParam(name: string): boolean {
+    if (name === MandatoryFuncObj || name === MandatoryArguments ||
+        name === MandatoryNewTarget || name === MandatoryThis) {
         return true;
     }
 
diff --git a/ts2panda/templates/irnodes.ts.erb b/ts2panda/templates/irnodes.ts.erb
index acb70721c2..a0c5845a8d 100755
--- a/ts2panda/templates/irnodes.ts.erb
+++ b/ts2panda/templates/irnodes.ts.erb
@@ -288,7 +288,7 @@ export function getInsnFormats(opcode: IRNodeKind) {
 }
 
 export abstract class IRNode {
-  private node: ts.Node | NodeKind = NodeKind.Normal;
+  private node: ts.Node | NodeKind = NodeKind.NORMAL;
   public static pg: PandaGen | undefined = undefined;
   constructor(
     readonly kind: IRNodeKind,
@@ -316,9 +316,9 @@ export abstract class IRNode {
   }
 
   getNodeName() {
-    if (this.node != NodeKind.Invalid &&
-        this.node != NodeKind.FirstNodeOfFunction &&
-        this.node != NodeKind.Normal) {
+    if (this.node != NodeKind.INVALID &&
+        this.node != NodeKind.FIRST_NODE_OF_FUNCTION &&
+        this.node != NodeKind.NORMAL) {
       return ts.SyntaxKind[(<ts.Node>this.node).kind];
     }
 
diff --git a/ts2panda/tests/builtIns.test.ts b/ts2panda/tests/builtIns.test.ts
index d17b95e933..7f24c2e251 100644
--- a/ts2panda/tests/builtIns.test.ts
+++ b/ts2panda/tests/builtIns.test.ts
@@ -47,6 +47,6 @@ describe("FunctionToStringTest", function () {
         CmdOptions.needRecordSourceCode = () => {return false};
         let pandaGen = snippetCompiler.getPandaGenByName('UnitTest.foo');
         let expected = "function foo() {return 123;}";
-        expect(pandaGen.getSourceCode() == expected).to.be.true;
+        expect(pandaGen.getSourceCode() === expected).to.be.true;
     })
 })
diff --git a/ts2panda/tests/expression/binary.test.ts b/ts2panda/tests/expression/binary.test.ts
index 7d36fa97a1..c70dcf7045 100644
--- a/ts2panda/tests/expression/binary.test.ts
+++ b/ts2panda/tests/expression/binary.test.ts
@@ -107,7 +107,7 @@ describe("BinaryOperationsTest", function () {
 
         expect(checkInstructions(insns, expected)).to.be.true;
 
-        let jumps = insns.filter(item => item instanceof Jeqz || item instanceof Jmp)
+        let jumps = insns.filter(item => item instanceof Jeqz || item instanceof Jmp);
 
         expect(jumps.length).to.equal(3);
     });
diff --git a/ts2panda/tests/expression/conditions.test.ts b/ts2panda/tests/expression/conditions.test.ts
index 5d903f230e..730b8d9535 100644
--- a/ts2panda/tests/expression/conditions.test.ts
+++ b/ts2panda/tests/expression/conditions.test.ts
@@ -115,7 +115,7 @@ describe("IfConditionTest", function () {
             endIfLabel,
         ];
         insns = insns.slice(4, insns.length - 1); // skip let a = 1; let b = 2; and return.
-        expect(checkInstructions(insns, expected)).to.be.true
+        expect(checkInstructions(insns, expected)).to.be.true;
     });
 
     it("if (a == b)", function () {
diff --git a/ts2panda/tests/expression/functionExpression.test.ts b/ts2panda/tests/expression/functionExpression.test.ts
index da9270f1ca..3d17933a22 100644
--- a/ts2panda/tests/expression/functionExpression.test.ts
+++ b/ts2panda/tests/expression/functionExpression.test.ts
@@ -57,7 +57,7 @@ describe("compileFunctionExpression", function () {
         let pandaGens = compileAllSnippet(source, passes);
         IRNode.pg = new PandaGen("", creatAstFromSnippet(``), 0, undefined);
 
-        let expected_func = [
+        let expectedFunc = [
             new Ldfunction(),
             new Sta(new VReg()),
             new Lda(new VReg()),
@@ -71,8 +71,8 @@ describe("compileFunctionExpression", function () {
 
         let checkCount = 0;
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "UnitTest.test") {
-                expect(checkInstructions(pg.getInsns(), expected_func), "check func insns").to.be.true;
+            if (pg.internalName === "UnitTest.test") {
+                expect(checkInstructions(pg.getInsns(), expectedFunc), "check func insns").to.be.true;
                 checkCount++;
             }
         });
@@ -89,11 +89,11 @@ describe("compileFunctionExpression", function () {
 
         let checkCount = 0;
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "UnitTest.a") {
+            if (pg.internalName === "UnitTest.a") {
                 checkCount++;
             }
 
-            if (pg.internalName == "UnitTest.func_main_0") {
+            if (pg.internalName === "UnitTest.func_main_0") {
 
                 pg.getInsns().forEach((insns) => {
                     if (insns instanceof Definefunc) {
@@ -117,11 +117,11 @@ describe("compileFunctionExpression", function () {
 
         let checkCount = 0;
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "UnitTest.a") {
+            if (pg.internalName === "UnitTest.a") {
                 checkCount++;
             }
 
-            if (pg.internalName == "UnitTest.func_main_0") {
+            if (pg.internalName === "UnitTest.func_main_0") {
 
                 pg.getInsns().forEach((insns) => {
                     if (insns instanceof Definefunc) {
@@ -146,11 +146,11 @@ describe("compileFunctionExpression", function () {
         let checkCount = 0;
 
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "UnitTest.a") {
+            if (pg.internalName === "UnitTest.a") {
                 checkCount++;
             }
 
-            if (pg.internalName == "UnitTest.func_main_0") {
+            if (pg.internalName === "UnitTest.func_main_0") {
 
                 pg.getInsns().forEach((insns) => {
                     if (insns instanceof Definefunc) {
@@ -172,7 +172,7 @@ describe("compileFunctionExpression", function () {
         let checkCount = 0;
         IRNode.pg = new PandaGen("", creatAstFromSnippet(``), 0, undefined);
 
-        let expected_func = [
+        let expectedFunc = [
             new Lda(new VReg()),
             new Sta(new VReg()),
             new Lda(new VReg()),
@@ -183,12 +183,12 @@ describe("compileFunctionExpression", function () {
         ];
 
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "UnitTest.p") {
-                expect(checkInstructions(pg.getInsns(), expected_func), "check arrow func insns").to.be.true;
+            if (pg.internalName === "UnitTest.p") {
+                expect(checkInstructions(pg.getInsns(), expectedFunc), "check arrow func insns").to.be.true;
                 checkCount++;
             }
 
-            if (pg.internalName == "UnitTest.func_main_0") {
+            if (pg.internalName === "UnitTest.func_main_0") {
 
                 pg.getInsns().forEach((insns) => {
                     if (insns instanceof Definefunc) {
@@ -229,7 +229,7 @@ describe("compileFunctionExpression", function () {
         let notRetLabel1 = new Label();
         let notThrowLabel1 = new Label();
 
-        let expected_func = [
+        let expectedFunc = [
             new Creategeneratorobj(new VReg()),
             new Sta(new VReg()),
             new Lda(new VReg()),
@@ -289,12 +289,12 @@ describe("compileFunctionExpression", function () {
         let checkCount = 0;
 
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "UnitTest.a") {
-                expect(checkInstructions(pg.getInsns(), expected_func), "check generator func insns").to.be.true;
+            if (pg.internalName === "UnitTest.a") {
+                expect(checkInstructions(pg.getInsns(), expectedFunc), "check generator func insns").to.be.true;
                 checkCount++;
             }
 
-            if (pg.internalName == "UnitTest.func_main_0") {
+            if (pg.internalName === "UnitTest.func_main_0") {
                 pg.getInsns().forEach((insns) => {
                     if (insns instanceof Definefunc) {
                         expect(insns.operands[1]).to.equal('UnitTest.a');
@@ -318,7 +318,7 @@ describe("compileFunctionExpression", function () {
         let endLabel = new Label();
         let nextLabel = new Label();
 
-        let expected_func = [
+        let expectedFunc = [
             new Asyncfunctionenter(),
             new Sta(new VReg()),
             beginLabel,
@@ -350,15 +350,15 @@ describe("compileFunctionExpression", function () {
         let checkCount = 0;
 
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "UnitTest.a") {
+            if (pg.internalName === "UnitTest.a") {
                 pg.getInsns().forEach(ins => {
                     console.log(ins.toString());
                 })
-                expect(checkInstructions(pg.getInsns(), expected_func), "check async func insns").to.be.true;
+                expect(checkInstructions(pg.getInsns(), expectedFunc), "check async func insns").to.be.true;
                 checkCount++;
             }
 
-            if (pg.internalName == "UnitTest.func_main_0") {
+            if (pg.internalName === "UnitTest.func_main_0") {
                 pg.getInsns().forEach((insns) => {
                     if (insns instanceof Definefunc) {
                         expect(insns.operands[1]).to.equal('UnitTest.a');
diff --git a/ts2panda/tests/expression/prefixOperations.test.ts b/ts2panda/tests/expression/prefixOperations.test.ts
index f81500f706..98de90cfc4 100644
--- a/ts2panda/tests/expression/prefixOperations.test.ts
+++ b/ts2panda/tests/expression/prefixOperations.test.ts
@@ -153,14 +153,14 @@ describe("PrefixOperationsTest", function () {
         let insns = compileMainSnippet("let i = 5; let j = ~i");
         IRNode.pg = new PandaGen("foo", creatAstFromSnippet("let i = 5; let j = ~i"), 0, undefined);
 
-        let temp_i = new VReg();
+        let tempI = new VReg();
 
         let expected = [
             new Ldai(new Imm(5)),
             new Sttoglobalrecord(new Imm(0), 'i'),
             new Tryldglobalbyname(new Imm(1), 'i'),
-            new Sta(temp_i),
-            new Lda(temp_i),
+            new Sta(tempI),
+            new Lda(tempI),
             new Not(new Imm(2)),
             new Sttoglobalrecord(new Imm(3), 'j'),
             new Returnundefined()
diff --git a/ts2panda/tests/expression/propertyAccess.test.ts b/ts2panda/tests/expression/propertyAccess.test.ts
index 2c57fcc0cd..23c977ef4f 100644
--- a/ts2panda/tests/expression/propertyAccess.test.ts
+++ b/ts2panda/tests/expression/propertyAccess.test.ts
@@ -110,16 +110,16 @@ describe("PropertyAccess", function () {
         ];
 
         compilerunit.forEach(element => {
-            if (element.internalName == "func_main_0") {
+            if (element.internalName === "func_main_0") {
                 let insns = element.getInsns();
 
                 insns = insns.slice(0, insns.length - 3);
                 expect(checkInstructions(insns, expected)).to.be.true;
             }
 
-            if (element.internalName == "myMethod") {
+            if (element.internalName === "myMethod") {
                 let parameterLength = element.getParameterLength();
-                expect(parameterLength == 1).to.be.true;
+                expect(parameterLength === 1).to.be.true;
             }
         });
     });
@@ -152,7 +152,7 @@ describe("PropertyAccess", function () {
         ];
 
         compilerunit.forEach(element => {
-            if (element.internalName == "func_main_0") {
+            if (element.internalName === "func_main_0") {
                 let insns = element.getInsns();
 
                 insns = insns.slice(0, insns.length - 3);
@@ -193,7 +193,7 @@ describe("PropertyAccess", function () {
         ];
 
         compilerunit.forEach(element => {
-            if (element.internalName == "func_main_0") {
+            if (element.internalName === "func_main_0") {
                 let insns = element.getInsns();
 
                 insns = insns.slice(0, insns.length - 3);
diff --git a/ts2panda/tests/expression/templateExpression.test.ts b/ts2panda/tests/expression/templateExpression.test.ts
index 5752c6c3df..0d2701771d 100644
--- a/ts2panda/tests/expression/templateExpression.test.ts
+++ b/ts2panda/tests/expression/templateExpression.test.ts
@@ -41,7 +41,7 @@ import { checkInstructions, compileMainSnippet } from "../utils/base";
 import { creatAstFromSnippet } from "../utils/asthelper"
 import { PandaGen } from '../../src/pandagen';
 
-function MicroCreateAddInsns(leftVal: number, rightVal: number, icSize: number) {
+function microCreateAddInsns(leftVal: number, rightVal: number, icSize: number): { insns: any[]; nextIc: number; } {
     let insns = [];
     let lhs = new VReg();
 
@@ -55,7 +55,7 @@ function MicroCreateAddInsns(leftVal: number, rightVal: number, icSize: number)
     return {insns: insns, nextIc: nextIc};
 }
 
-function MicroCreateObjAndPropInsns(icSize: number) {
+function microCreateObjAndPropInsns(icSize: number): { insns: any[]; nextIc: number; } {
     let insns = [];
     let obj = new VReg();
     let val = new VReg();
@@ -71,7 +71,7 @@ function MicroCreateObjAndPropInsns(icSize: number) {
     return {insns: insns, nextIc: nextIc};
 }
 
-function MicroGetTemplateObject(rawArr: VReg, cookedArr: VReg, icSize: number) {
+function microGetTemplateObject(rawArr: VReg, cookedArr: VReg, icSize: number): { insns: any[]; nextIc: number; } {
     let insns = [];
     let objReg = new VReg();
     let indexReg = new VReg();
diff --git a/ts2panda/tests/lexenv.test.ts b/ts2panda/tests/lexenv.test.ts
index ac103f52d5..a74cc23dc4 100644
--- a/ts2panda/tests/lexenv.test.ts
+++ b/ts2panda/tests/lexenv.test.ts
@@ -74,7 +74,7 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
 
         expect(globalScope.getChildVariableScope().length, "should not have any children!").to.be.equal(0);
         expect(globalScope.getParentVariableScope(), "should not have any children!").to.be.equal(null);
-        expect(globalScope.getBindingNode() == sourceFile, "functionblock.node should equal to sourceFile").to.be.true;
+        expect(globalScope.getBindingNode() === sourceFile, "functionblock.node should equal to sourceFile").to.be.true;
     });
 
     it("test CompilerDriver.scanFunctions-with-embedded-function", function () {
@@ -110,7 +110,7 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
         let grandchildren0 = son0.getChildVariableScope();
         let parentOfSon0 = son0.getParentVariableScope();
         let bindingNodeOfSon0 = <ts.Node>son0.getBindingNode();
-        expect(grandchildren0.length == 2, "son should have two children!").to.be.true;
+        expect(grandchildren0.length === 2, "son should have two children!").to.be.true;
         expect(parentOfSon0, "son's parent should equal root!").deep.equal(globalScope);
         expect(bindingNodeOfSon0.kind, "son's parent should equal root!").deep.equal(ts.SyntaxKind.FunctionDeclaration);
         // check grandson
@@ -131,7 +131,7 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
         let grandchildren1 = son1.getChildVariableScope();
         let parentOfSon1 = son1.getParentVariableScope();
         let bindingNodeOfSon1 = <ts.Node>son1.getBindingNode();
-        expect(grandchildren1.length == 0, "son1 should have two children!").to.be.true;
+        expect(grandchildren1.length === 0, "son1 should have two children!").to.be.true;
         expect(parentOfSon1, "son1's parent should equal root!").deep.equal(globalScope);
         expect(bindingNodeOfSon1.kind, "son1's parent should equal root!").deep.equal(ts.SyntaxKind.FunctionExpression);
     });
@@ -147,7 +147,7 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
         recorder.record();
         let postOrderVariableScopes = compilerDriver.postOrderAnalysis(globalScope);
 
-        expect(postOrderVariableScopes.length == 1, "postorder array length not correct");
+        expect(postOrderVariableScopes.length === 1, "postorder array length not correct");
         expect(postOrderVariableScopes[0]).to.be.deep.equal(globalScope);
     });
 
@@ -172,7 +172,7 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
         let postOrderVariableScopes = compilerDriver.postOrderAnalysis(globalScope);
 
         let children = globalScope.getChildVariableScope();
-        expect(postOrderVariableScopes.length == 5, "postorder array length not correct");
+        expect(postOrderVariableScopes.length === 5, "postorder array length not correct");
         expect(postOrderVariableScopes[0]).to.be.deep.equal(children[0].getChildVariableScope()[0]);
         expect(postOrderVariableScopes[1]).to.be.deep.equal(children[0].getChildVariableScope()[1]);
         expect(postOrderVariableScopes[2]).to.be.deep.equal(children[0]);
@@ -227,7 +227,7 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
 
         let children = globalScope.getChildVariableScope();
         let grandchildren1 = children[1].getChildVariableScope();
-        expect(postOrderVariableScopes.length == 6, "postorder array length not correct");
+        expect(postOrderVariableScopes.length === 6, "postorder array length not correct");
         expect(postOrderVariableScopes[0]).to.be.deep.equal(children[0]);
         expect(postOrderVariableScopes[1]).to.be.deep.equal(grandchildren1[0].getChildVariableScope()[0]);
         expect(postOrderVariableScopes[2]).to.be.deep.equal(grandchildren1[0].getChildVariableScope()[1]);
@@ -355,7 +355,7 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
 
         let pandaGens = compileAllSnippet(source);
         IRNode.pg = new PandaGen("foo", creatAstFromSnippet(`class C {}; export {C}`), 0, undefined);
-        let expected_main = [
+        let expectedMain = [
             new Lda(new VReg()),
             new Stglobalvar(new Imm(0), "outer"),
             new Definefunc(new Imm(1), "UnitTest.func", new Imm(0)),
@@ -365,17 +365,17 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
             new Returnundefined()
         ];
         IRNode.pg = new PandaGen("foo", creatAstFromSnippet(`class C {}; export {C}`), 0, undefined);
-        let expected_func = [
+        let expectedFunc = [
             new Ldai(new Imm(2)),
             new Stglobalvar(new Imm(0), "outer"),
             new Returnundefined()
         ];
 
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "UnitTest.func_main_0") {
-                expect(checkInstructions(pg.getInsns(), expected_main)).to.be.true;
-            } else if (pg.internalName == "UnitTest.func") {
-                expect(checkInstructions(pg.getInsns(), expected_func)).to.be.true;
+            if (pg.internalName === "UnitTest.func_main_0") {
+                expect(checkInstructions(pg.getInsns(), expectedMain)).to.be.true;
+            } else if (pg.internalName === "UnitTest.func") {
+                expect(checkInstructions(pg.getInsns(), expectedFunc)).to.be.true;
             }
         })
     });
@@ -392,7 +392,7 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
         let passes = [new CacheExpander()];
         let pandaGens = compileAllSnippet(source, passes);
         IRNode.pg = new PandaGen("foo", creatAstFromSnippet(`class C {}; export {C}`), 0, undefined);
-        let expected_main = [
+        let expectedMain = [
             new Definefunc(new Imm(0), "UnitTest.func", new Imm(0)),
             new Stglobalvar(new Imm(1), "func"), // global.func = func_func_1
             new Ldai(new Imm(1)), // value = 1
@@ -401,7 +401,7 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
         ];
 
         IRNode.pg = new PandaGen("foo", creatAstFromSnippet(`class C {}; export {C}`), 0, undefined);
-        let expected_func = [
+        let expectedFunc = [
             new Ldai(new Imm(2)),
             // ...insnsStoreLexVar_func,
             new Trystglobalbyname(new Imm(0), "outer"),
@@ -410,13 +410,13 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
 
         pandaGens.forEach((pg) => {
             let scope = <VariableScope>pg.getScope();
-            if (pg.internalName == "UnitTest.func_main_0") {
-                expect(checkInstructions(pg.getInsns(), expected_main), "check main insns").to.be.true;
+            if (pg.internalName === "UnitTest.func_main_0") {
+                expect(checkInstructions(pg.getInsns(), expectedMain), "check main insns").to.be.true;
                 expect(scope.getNumLexEnv(), "main scope has 0 lexvar").to.be.equal(0);
                 // expect(scope.hasLexEnv(), "main scope has lexenv").to.be.true;
-            } else if (pg.internalName == "UnitTest.func") {
+            } else if (pg.internalName === "UnitTest.func") {
 
-                expect(checkInstructions(pg.getInsns(), expected_func), "check func insns").to.be.true;
+                expect(checkInstructions(pg.getInsns(), expectedFunc), "check func insns").to.be.true;
                 expect(scope.getNumLexEnv(), "func scope has 1 lexvar").to.be.equal(0);
                 // expect(scope.hasLexEnv(), "func scope has lexenv").to.be.true;
             }
@@ -439,7 +439,7 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
         `;
 
         IRNode.pg = new PandaGen("foo", creatAstFromSnippet(`class C {}; export {C}`), 0, undefined);
-        let expect_outer: IRNode[] = [
+        let expectOuter: IRNode[] = [
             new Newlexenv(new Imm(2)),
             new Sta(new VReg()),
             new Lda(new VReg()),
@@ -460,7 +460,7 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
         ];
 
         IRNode.pg = new PandaGen("foo", creatAstFromSnippet(`class C {}; export {C}`), 0, undefined);
-        let expect_anonymous = [
+        let expectAnonymous = [
             new Ldlexvar(new Imm(0), new Imm(0)),
             new Sta(new VReg()),
             new Lda(new VReg()),
@@ -505,7 +505,7 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
         let globalA = globalScope!.findLocal("a");
         expect(globalA instanceof GlobalVariable, "globalA is GlobalVariable").to.be.true;
 
-        expect(checkInstructions(anonymousPg!.getInsns(), expect_anonymous), "check anonymous func ins").to.be.true;
-        expect(checkInstructions(outerPg!.getInsns(), expect_outer), "check outer func ins").to.be.true;
+        expect(checkInstructions(anonymousPg!.getInsns(), expectAnonymous), "check anonymous func ins").to.be.true;
+        expect(checkInstructions(outerPg!.getInsns(), expectOuter), "check outer func ins").to.be.true;
     });
 });
diff --git a/ts2panda/tests/regAllocator.test.ts b/ts2panda/tests/regAllocator.test.ts
index 185ebd3594..a68baee24c 100644
--- a/ts2panda/tests/regAllocator.test.ts
+++ b/ts2panda/tests/regAllocator.test.ts
@@ -50,7 +50,7 @@ function checkRegisterNumber(left: IRNode, right: IRNode): boolean {
         let l = lo[i];
         let r = ro[i];
         if (l instanceof VReg && r instanceof VReg) {
-            if (!((<VReg>l).num == (<VReg>r).num)) {
+            if (!((<VReg>l).num === (<VReg>r).num)) {
                 return false;
             }
         }
@@ -253,7 +253,7 @@ describe("RegAllocator", function () {
         let para2 = pandaGen.getTemp();
         let para3 = pandaGen.getTemp();
 
-        pandaGen.getInsns().push(new Callrange(new Imm(0), new Imm(3), [para1, para2, para3]))
+        pandaGen.getInsns().push(new Callrange(new Imm(0), new Imm(3), [para1, para2, para3]));
 
         pandaGen.freeTemps(para1, para3, para2);
 
diff --git a/ts2panda/tests/statements/functionDeclaration.test.ts b/ts2panda/tests/statements/functionDeclaration.test.ts
index 6405c9cd96..938c97d6cc 100644
--- a/ts2panda/tests/statements/functionDeclaration.test.ts
+++ b/ts2panda/tests/statements/functionDeclaration.test.ts
@@ -101,7 +101,7 @@ describe("FunctionDeclarationTest", function () {
         expect(foo != undefined).to.be.true;
         expect(foo instanceof LocalVariable).to.be.true;
         let parameterLength = functionPg!.getParameterLength();
-        expect(parameterLength == 0).to.be.true;
+        expect(parameterLength === 0).to.be.true;
     });
 
     it("function expression", function () {
@@ -124,14 +124,14 @@ describe("FunctionDeclarationTest", function () {
         let endLabel = new Label();
 
         IRNode.pg = new PandaGen("", creatAstFromSnippet(``), 0, undefined);
-        let expected_main = [
+        let expectedMain = [
             new Definefunc(new Imm(0), "UnitTest.test", new Imm(1)),
             new Stglobalvar(new Imm(1), "test"),
             new Returnundefined()
         ];
 
         IRNode.pg = new PandaGen("", creatAstFromSnippet(``), 0, undefined);
-        let expected_func = [
+        let expectedFunc = [
             // func_test_0
             new Lda(new VReg()),
             new Stricteq(new Imm(0), undefinedVReg),
@@ -143,14 +143,14 @@ describe("FunctionDeclarationTest", function () {
         ];
 
         compilerunit.forEach(element => {
-            if (element.internalName == "UnitTest.func_main_0") {
+            if (element.internalName === "UnitTest.func_main_0") {
                 let insns = element.getInsns();
-                expect(checkInstructions(insns, expected_main)).to.be.true;
-            } else if (element.internalName == "UnitTest.test") {
+                expect(checkInstructions(insns, expectedMain)).to.be.true;
+            } else if (element.internalName === "UnitTest.test") {
                 let insns = element.getInsns();
-                expect(checkInstructions(insns, expected_func)).to.be.true;
+                expect(checkInstructions(insns, expectedFunc)).to.be.true;
                 let parameterLength = element.getParameterLength();
-                expect(parameterLength == 1).to.be.true;
+                expect(parameterLength === 1).to.be.true;
             }
         });
     });
@@ -162,7 +162,7 @@ describe("FunctionDeclarationTest", function () {
         IRNode.pg = new PandaGen("", creatAstFromSnippet(``), 0, undefined);
         let idx = new Imm(1);
         let lastParam = new VReg();
-        let expected_func = [
+        let expectedFunc = [
             // func_test_0
             new Copyrestargs(idx),
             new Sta(lastParam),
@@ -172,6 +172,6 @@ describe("FunctionDeclarationTest", function () {
         let functionPg = snippetCompiler.getPandaGenByName("UnitTest.test");
         let insns = functionPg!.getInsns();
 
-        expect(checkInstructions(insns, expected_func)).to.be.true;
+        expect(checkInstructions(insns, expectedFunc)).to.be.true;
     });
 });
diff --git a/ts2panda/tests/statements/variableDeclaration.test.ts b/ts2panda/tests/statements/variableDeclaration.test.ts
index 88db2c51f3..3b9c3ec158 100644
--- a/ts2panda/tests/statements/variableDeclaration.test.ts
+++ b/ts2panda/tests/statements/variableDeclaration.test.ts
@@ -257,6 +257,6 @@ describe("VariableDeclarationTest", function () {
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
         let i = scope!.findLocal("i");
-        expect(i == undefined).to.be.true; // not in global
+        expect(i === undefined).to.be.true; // not in global
     });
 });
diff --git a/ts2panda/tests/strictmode/function.js b/ts2panda/tests/strictmode/function.js
index bde7776c4c..465bc4424c 100644
--- a/ts2panda/tests/strictmode/function.js
+++ b/ts2panda/tests/strictmode/function.js
@@ -15,13 +15,13 @@
 
 function add(a,b) {
     "use strict";
-    var x = 12;
+    let x = 12;
     return a + b + x;
 }
 
 function sub(a,b) {
-    var y = 12;
+    let y = 12;
     return a + b - y;
 }
 
-var z = 13;
\ No newline at end of file
+let z = 13;
\ No newline at end of file
diff --git a/ts2panda/tests/strictmode/function_nest1.js b/ts2panda/tests/strictmode/function_nest1.js
index 3bdaaf4230..223b5babb4 100755
--- a/ts2panda/tests/strictmode/function_nest1.js
+++ b/ts2panda/tests/strictmode/function_nest1.js
@@ -15,9 +15,9 @@
 
 function func(){
     "use strict";
-    var x = 10;
+    let x = 10;
     function add(a,b) {
-        var y = 12;
+        let y = 12;
         return a + b + y;
     }
 }
diff --git a/ts2panda/tests/strictmode/function_nest2.js b/ts2panda/tests/strictmode/function_nest2.js
index 59ae2a911d..e76de3abef 100755
--- a/ts2panda/tests/strictmode/function_nest2.js
+++ b/ts2panda/tests/strictmode/function_nest2.js
@@ -14,11 +14,11 @@
  */
 
 function func(){
-    var x = 10;
+    let x = 10;
     function add(a,b) {
         "use strict";
-        var y = 12;
+        let y = 12;
         return a+b+y;
     }
-    var z = 14;
+    let z = 14;
 }
\ No newline at end of file
diff --git a/ts2panda/tests/strictmode/strictmode.test.ts b/ts2panda/tests/strictmode/strictmode.test.ts
index e6430b32f4..bc4741cba2 100644
--- a/ts2panda/tests/strictmode/strictmode.test.ts
+++ b/ts2panda/tests/strictmode/strictmode.test.ts
@@ -34,7 +34,7 @@ function createSourceFile(filename: string): ts.SourceFile {
 
 function recordNodes(node: ts.Node, flag: boolean): boolean {
     node.forEachChild(childNode => {
-        expect(isStrictMode(childNode) == flag).to.be.true;
+        expect(isStrictMode(childNode) === flag).to.be.true;
         recordNodes(childNode, flag);
     });
 
@@ -57,7 +57,7 @@ describe("strict_mode", function () {
             if (isFunctionLikeDeclaration(childNode)) {
                 let funcId = <ts.Identifier>(<ts.FunctionDeclaration>childNode).name;
                 let funcName = jshelpers.getTextOfIdentifierOrLiteral(funcId);
-                if (funcName == "add") {
+                if (funcName === "add") {
                     recordNodes(childNode, true);
                 } else {
                     recordNodes(childNode, false);
diff --git a/ts2panda/tests/types/class.test.ts b/ts2panda/tests/types/class.test.ts
index 0ee5e903a6..4097b5c88f 100644
--- a/ts2panda/tests/types/class.test.ts
+++ b/ts2panda/tests/types/class.test.ts
@@ -262,8 +262,8 @@ describe("class tests in class.test.ts", function () {
         let locals = functionPg!.getLocals();
         // check vreg
         let extectedVRegTypePair = [
-            ["#3#animal", shift + 1],
-            ["#4#dog", shift + 3],
+            ["#3#Animal", shift + 1],
+            ["#4#Dog", shift + 3],
             ["#5#d", shift + 5],
         ]
         let vreg2TypeMap = createVRegTypePair(extectedVRegTypePair);
@@ -307,8 +307,8 @@ describe("class tests in class.test.ts", function () {
         let locals = functionPg!.getLocals();
         // check vreg
         let extectedVRegTypePair = [
-            ["#3#base1", shift + 1],
-            ["#4#base2", shift + 2],
+            ["#3#Base1", shift + 1],
+            ["#4#Base2", shift + 2],
             ["#5#A", shift + 3],
             ["#6#a", shift + 4],
         ]
diff --git a/ts2panda/tests/types/class/class_abstract.ts b/ts2panda/tests/types/class/class_abstract.ts
index a796345b64..7d39bba77b 100644
--- a/ts2panda/tests/types/class/class_abstract.ts
+++ b/ts2panda/tests/types/class/class_abstract.ts
@@ -14,15 +14,15 @@
  */
 
 {
-    abstract class animal {
+    abstract class Animal {
         eat() { };
     }
 
-    class dog extends animal {
+    class Dog extends Animal {
         constructor() {
             super();
         }
     }
 
-    let d = new dog();
+    let d = new Dog();
 }
\ No newline at end of file
diff --git a/ts2panda/tests/types/class/class_implements.ts b/ts2panda/tests/types/class/class_implements.ts
index 76f79672c9..5dfcb1b9bd 100644
--- a/ts2panda/tests/types/class/class_implements.ts
+++ b/ts2panda/tests/types/class/class_implements.ts
@@ -14,8 +14,8 @@
  */
 
 {
-    class base1 { }
-    class base2 { }
-    class A implements base1, base2 { }
+    class Base1 { }
+    class Base2 { }
+    class A implements Base1, Base2 { }
     let a = new A();
 }
\ No newline at end of file
diff --git a/ts2panda/tests/types/function.test.ts b/ts2panda/tests/types/function.test.ts
index b6b640efcd..b037a4e984 100644
--- a/ts2panda/tests/types/function.test.ts
+++ b/ts2panda/tests/types/function.test.ts
@@ -77,7 +77,7 @@ describe("function tests in function.test.ts", function () {
                 [2, 2], [24, "snippet_1"], [24, "snippet_2"], [2, 0]
             ],
             [
-                [2, 3], [2, 0], [5, "multi_local"],
+                [2, 3], [2, 0], [5, "multiLocal"],
                 [2, 0], [2, 0], [25, 0]
             ],
             [
diff --git a/ts2panda/tests/types/function/function_multi_para.ts b/ts2panda/tests/types/function/function_multi_para.ts
index ef95661ff1..9dc3362de2 100644
--- a/ts2panda/tests/types/function/function_multi_para.ts
+++ b/ts2panda/tests/types/function/function_multi_para.ts
@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-function multi_local() {
+function multiLocal() {
     function emptyFunc(num: number, str:string): string {
         return str;
     }
diff --git a/ts2panda/tests/types/typeUtils.ts b/ts2panda/tests/types/typeUtils.ts
index 88fafdb376..6735d9ec89 100644
--- a/ts2panda/tests/types/typeUtils.ts
+++ b/ts2panda/tests/types/typeUtils.ts
@@ -41,7 +41,7 @@ let options = {
     alwaysStrict: true
 }
 
-export function compileTsWithType(fileName: string) {
+export function compileTsWithType(fileName: string): { literalBufferArray: LiteralBuffer[]; snippetCompiler: SnippetCompiler; } {
 
     CmdOptions.parseUserCmd([""]);
     let filePath = [fileName];
@@ -62,7 +62,7 @@ export function compileTsWithType(fileName: string) {
     }
 }
 
-export function createVRegTypePair(input: any) {
+export function createVRegTypePair(input: any): Map<string, number> {
     let id2TypeIndex: Map<string, number> = new Map<string, number>();
     for (let rol of input) {
         id2TypeIndex.set(rol[0], rol[1]);
@@ -73,12 +73,12 @@ export function createVRegTypePair(input: any) {
 export function compareVReg2Type(expectedMap: Map<string, number>, generated: VReg[]): boolean {
     for (let vreg of generated) {
         let name = vreg.getVariableName();
-        if (name == "4funcObj" || name == "4newTarget" || name == "this") {
+        if (name === "4funcObj" || name === "4newTarget" || name === "this") {
             continue;
         }
-        let vregMarker = "#" + vreg.num + "#" + vreg.getVariableName()
+        let vregMarker = "#" + vreg.num + "#" + vreg.getVariableName();
         if (!expectedMap.has(vregMarker)) {
-            console.log("verg not found: ", vregMarker)
+            console.log("verg not found: ", vregMarker);
             return false;
         }
         if (expectedMap.get(vregMarker) != vreg.getTypeIndex()) {
@@ -92,7 +92,7 @@ export function compareVReg2Type(expectedMap: Map<string, number>, generated: VR
     return true;
 }
 
-export function createLiteralBufferArray(input: any) {
+export function createLiteralBufferArray(input: any): LiteralBuffer[] {
     let literalBufferArray: Array<LiteralBuffer> = new Array<LiteralBuffer>();
     for (let i = 0; i < input.length; i++) {
         let buff = input[i];
@@ -107,7 +107,7 @@ export function createLiteralBufferArray(input: any) {
     return literalBufferArray;
 }
 
-function printLiteralLog(expected: Literal, generated: Literal) {
+function printLiteralLog(expected: Literal, generated: Literal): void {
     console.log("expected literals:");
     console.log(expected);
     console.log("unmatched literals:");
diff --git a/ts2panda/tests/utils/base.ts b/ts2panda/tests/utils/base.ts
index 82def16907..9b5bcd32ce 100644
--- a/ts2panda/tests/utils/base.ts
+++ b/ts2panda/tests/utils/base.ts
@@ -94,7 +94,7 @@ function basicOperandsEqual(left: OperandType, right: OperandType): boolean {
 
     if (isId(left) && isId(right)) {
         // string compare
-        return left == right;
+        return left === right;
     }
 
     let str = "operandsEqual: operands are not one of this types: VReg | Imm | Label | BuiltIns | string\n";
@@ -132,7 +132,7 @@ export function checkInstructions(actual: IRNode[], expected: IRNode[], checkFn?
     }
 
     if (actual.length !== expected.length) {
-        console.log("actual.length:" + actual.length + " expected.length:" + expected.length)
+        console.log("actual.length:" + actual.length + " expected.length:" + expected.length);
         return false;
     }
 
@@ -154,8 +154,8 @@ export function compileAllSnippet(snippet: string, passes?: Pass[], literalBuffe
         CmdOptions.setWatchEvaluateExpressionArgs(['','']);
     }
     CmdOptions.setMergeAbc(true);
-    CmdOptions.isWatchEvaluateExpressionMode() ? setGlobalStrict(true)
-                            : setGlobalStrict(jshelpers.isEffectiveStrictModeSourceFile(sourceFile, compileOptions));
+    CmdOptions.isWatchEvaluateExpressionMode() ? setGlobalStrict(true) :
+        setGlobalStrict(jshelpers.isEffectiveStrictModeSourceFile(sourceFile, compileOptions));
     let compilerDriver = new CompilerDriver('UnitTest', 'UnitTest');
     CompilerDriver.srcNode = sourceFile;
 
@@ -178,14 +178,14 @@ export function compileMainSnippet(snippet: string, pandaGen?: PandaGen, scope?:
     // only return main function
     if (compileFunc) {
         compileUnits.filter((pg) => {
-            return (pg.internalName == "UnitTest.func_main_0");
+            return (pg.internalName === "UnitTest.func_main_0");
         })
     }
 
     return compileUnits[0].getInsns();
 }
 
-export function compileAfterSnippet(snippet: string, name:string, isCommonJs: boolean = false) {
+export function compileAfterSnippet(snippet: string, name:string, isCommonJs: boolean = false): any {
     let compileUnits = null;
     CmdOptions.parseUserCmd([""]);
     CmdOptions.setMergeAbc(true);
@@ -230,17 +230,17 @@ export function getCompileOptions(): ts.CompilerOptions {
 
 export class SnippetCompiler {
     pandaGens: PandaGen[] = [];
-    compile(snippet: string, passes?: Pass[], literalBufferArray?: Array<LiteralBuffer>) {
+    compile(snippet: string, passes?: Pass[], literalBufferArray?: Array<LiteralBuffer>): PandaGen[] {
         this.pandaGens = compileAllSnippet(snippet, passes, literalBufferArray);
         return this.pandaGens;
     }
 
-    compileAfter(snippet: string, name: string, passes?: Pass[], literalBufferArray?: Array<LiteralBuffer>) {
+    compileAfter(snippet: string, name: string, passes?: Pass[], literalBufferArray?: Array<LiteralBuffer>): PandaGen[] {
         this.pandaGens = compileAfterSnippet(snippet, name);
         return this.pandaGens;
     }
 
-    compileCommonjs(snippet: string, name: string) {
+    compileCommonjs(snippet: string, name: string): PandaGen[] {
         this.pandaGens = compileAfterSnippet(snippet, name, true);
         return this.pandaGens;
     }
@@ -262,7 +262,7 @@ export class SnippetCompiler {
 
     getPandaGenByName(name: string): PandaGen | undefined {
         let pgs = this.pandaGens.filter(pg => {
-            return (pg.internalName == name);
+            return (pg.internalName === name);
         })
         return pgs[0];
     }
diff --git a/ts2panda/tests/utils/example_asthelper.ts b/ts2panda/tests/utils/example_asthelper.ts
index 3daf802421..0973e8fd54 100644
--- a/ts2panda/tests/utils/example_asthelper.ts
+++ b/ts2panda/tests/utils/example_asthelper.ts
@@ -15,12 +15,12 @@
 
 import * as asthelper from "./asthelper";
 
-function testCreateAstFromSnippet() {
+function testCreateAstFromSnippet(): void {
     let ast = asthelper.creatAstFromSnippet("var aaa = 10");
     console.log(ast.getText());
 }
-function testCreateAstFromFile() {
-    const absolutePath = __dirname + "/example_asthelper.js"
+function testCreateAstFromFile(): void {
+    const absolutePath = __dirname + "/example_asthelper.js";
     let ast = asthelper.creatAstFromFile(absolutePath);
     console.log(ast.getText());
 }
diff --git a/ts2panda/tests/watch_expression/addWatch.test.ts b/ts2panda/tests/watch_expression/addWatch.test.ts
index 586e49acf2..9e11e691b4 100644
--- a/ts2panda/tests/watch_expression/addWatch.test.ts
+++ b/ts2panda/tests/watch_expression/addWatch.test.ts
@@ -335,7 +335,7 @@ describe("WatchExpressions", function () {
             new Return()
         ];
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "#1#") {
+            if (pg.internalName === "#1#") {
                 expect(checkInstructions(pg.getInsns(), expected)).to.be.true;
             }
         });
@@ -511,7 +511,7 @@ describe("WatchExpressions", function () {
             new Return()
         ];
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "func_main_0") {
+            if (pg.internalName === "func_main_0") {
                 expect(checkInstructions(pg.getInsns(), expected)).to.be.true;
             }
         });
@@ -639,7 +639,7 @@ describe("WatchExpressions", function () {
         ];
 
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "a") {
+            if (pg.internalName === "a") {
                 expect(checkInstructions(pg.getInsns(), expected)).to.be.true;
             }
         });
@@ -844,7 +844,7 @@ describe("WatchExpressions", function () {
         ];
 
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "func") {
+            if (pg.internalName === "func") {
                 expect(checkInstructions(pg.getInsns(), expected)).to.be.true;
             }
         });
@@ -875,7 +875,7 @@ describe("WatchExpressions", function () {
         ];
 
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "#1#") {
+            if (pg.internalName === "#1#") {
                 expect(checkInstructions(pg.getInsns(), expected)).to.be.true;
             }
         });
@@ -906,7 +906,7 @@ describe("WatchExpressions", function () {
             new Return()
         ];
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "func_main_0") {
+            if (pg.internalName === "func_main_0") {
                 expect(checkInstructions(pg.getInsns(), expected)).to.be.true;
             }
         });
diff --git a/ts2panda/tools/astPrinter.ts b/ts2panda/tools/astPrinter.ts
index 4a1a16be72..f962e90bb7 100644
--- a/ts2panda/tools/astPrinter.ts
+++ b/ts2panda/tools/astPrinter.ts
@@ -77,10 +77,10 @@ export namespace AST {
         }
 
         function isFile(node: any): node is ts.SourceFile {
-            return ((typeof (node) === "object") && ("kind" in node) && (node.kind == ts.SyntaxKind.SourceFile));
+            return ((typeof (node) === "object") && ("kind" in node) && (node.kind === ts.SyntaxKind.SourceFile));
         }
 
-        function Array2String(name: (undefined | string), array: ts.Node[], tab: number): string {
+        function array2String(name: (undefined | string), array: ts.Node[], tab: number): string {
             const repeat = ' '.repeat(tab);
             let retVal = "";
             let subStr = "";
@@ -90,7 +90,7 @@ export namespace AST {
             }
 
             for (const [key, value] of Object.entries(array)) {
-                subStr += Node2String(undefined, value, tab + tabSize);
+                subStr += node2String(undefined, value, tab + tabSize);
             }
 
             if (subStr) {
@@ -104,7 +104,7 @@ export namespace AST {
             return retVal;
         }
 
-        function Node2String(name: (undefined | string), node: ts.Node, tab: number): string {
+        function node2String(name: (undefined | string), node: ts.Node, tab: number): string {
             if (!isNode(node)) {
                 return "";
             }
@@ -119,17 +119,17 @@ export namespace AST {
                 retVal += repeat + name + ':' + '\n';
             }
 
-            subStr = kindNames.join('/')
+            subStr = kindNames.join('/');
             retVal += repeat + subStr + ',' + ' ' + kind + '\n';
-            subStr = ""
+            subStr = "";
 
             for (const [key, value] of Object.entries(node)) {
                 if (isArray(value)) {
-                    subStr += Array2String(key, value, tab + tabSize);
+                    subStr += array2String(key, value, tab + tabSize);
                 }
 
                 if (isNode(value)) {
-                    subStr += Node2String(key, value, tab + tabSize);
+                    subStr += node2String(key, value, tab + tabSize);
                 }
             }
 
@@ -155,7 +155,7 @@ export namespace AST {
 
             for (const value of file.statements) {
                 if (isNode(value)) {
-                    subStr += Node2String(undefined, value, tab + tabSize);
+                    subStr += node2String(undefined, value, tab + tabSize);
                 }
             }
 
@@ -204,8 +204,9 @@ function run(args: string[], useDefault?: boolean): void {
         return path.resolve(file);
     });
 
-    if (useDefault === true)
-        parsed.options = Object.assign(defaultOptions, parsed.options)
+    if (useDefault === true) {
+        parsed.options = Object.assign(defaultOptions, parsed.options);
+    }
 
     console.log(AST.Printer.Convert2String(parsed.fileNames, parsed.options));
 }
diff --git a/ts2panda/webpack.config.js b/ts2panda/webpack.config.js
index fb1f01af29..5ad5cf8e8a 100644
--- a/ts2panda/webpack.config.js
+++ b/ts2panda/webpack.config.js
@@ -27,7 +27,7 @@ let cleanOptions = {
 };
 
 function initConfig(config, envArgs) {
-    console.log(envArgs.buildMode)
+    console.log(envArgs.buildMode);
     Object.assign(config, {
         optimization: {
             minimize: envArgs.buildMode !== 'debug'
-- 
Gitee