From 9b4eb9fab4a71568b8a973d09522dbfa7ed8fae0 Mon Sep 17 00:00:00 2001
From: jiangkaiwen <jiangkaiwen2@huawei.com>
Date: Thu, 30 Mar 2023 10:59:47 +0800
Subject: [PATCH] Fix codecheck warnings of the monthly branch

Issue:I6RJJ1

Signed-off-by: jiangkaiwen <jiangkaiwen2@huawei.com>
Change-Id: I664048ca17e5258395c6b27e3f358968484944ba
---
 ts2panda/src/addVariable2Scope.ts             |  2 +-
 ts2panda/src/assemblyDumper.ts                | 18 ++++----
 ts2panda/src/astutils.ts                      |  4 +-
 ts2panda/src/base/bcGenUtil.ts                |  2 +-
 ts2panda/src/base/iterator.ts                 |  4 +-
 ts2panda/src/base/literal.ts                  |  2 +-
 ts2panda/src/base/lreference.ts               |  6 +--
 ts2panda/src/base/properties.ts               | 30 ++++++-------
 ts2panda/src/base/typeSystem.ts               |  4 +-
 ts2panda/src/base/util.ts                     | 18 ++++----
 ts2panda/src/cmdOptions.ts                    |  8 ++--
 ts2panda/src/compiler.ts                      | 42 +++++++++----------
 ts2panda/src/compilerDriver.ts                |  8 ++--
 ts2panda/src/compilerStatistics.ts            |  4 +-
 ts2panda/src/compilerUtils.ts                 |  8 ++--
 ts2panda/src/debuginfo.ts                     |  4 +-
 .../src/expression/arrayLiteralExpression.ts  |  6 +--
 ts2panda/src/expression/callExpression.ts     |  6 +--
 .../src/expression/memberAccessExpression.ts  |  6 +--
 ts2panda/src/expression/metaProperty.ts       |  2 +-
 .../src/expression/objectLiteralExpression.ts | 22 +++++-----
 .../src/expression/parenthesizedExpression.ts |  4 +-
 ts2panda/src/expression/regularExpression.ts  |  6 +--
 ts2panda/src/index.ts                         | 10 ++---
 ts2panda/src/lexenv.ts                        |  4 +-
 ts2panda/src/lexicalBinder.ts                 |  6 +--
 ts2panda/src/log.ts                           |  2 +-
 ts2panda/src/pandagen.ts                      |  4 +-
 ts2panda/src/recorder.ts                      | 28 ++++++-------
 ts2panda/src/regAllocator.ts                  |  8 ++--
 ts2panda/src/scope.ts                         | 22 +++++-----
 ts2panda/src/statement/classStatement.ts      | 28 ++++++-------
 ts2panda/src/statement/forOfStatement.ts      |  2 +-
 ts2panda/src/statement/labelTarget.ts         |  4 +-
 ts2panda/src/statement/returnStatement.ts     |  4 +-
 ts2panda/src/statement/tryStatement.ts        |  6 +--
 ts2panda/src/strictMode.ts                    |  6 +--
 ts2panda/src/syntaxCheckHelper.ts             | 10 ++---
 ts2panda/src/syntaxChecker.ts                 | 34 +++++++--------
 ts2panda/src/syntaxCheckerForStrcitMode.ts    |  6 +--
 ts2panda/src/ts2panda.ts                      | 14 +++----
 ts2panda/src/typeChecker.ts                   | 24 +++++------
 ts2panda/src/typeRecorder.ts                  |  2 +-
 ts2panda/src/variable.ts                      | 20 ++++-----
 ts2panda/tests/builtIns.test.ts               |  2 +-
 .../expression/functionExpression.test.ts     | 26 ++++++------
 .../tests/expression/propertyAccess.test.ts   | 10 ++---
 ts2panda/tests/lexenv.test.ts                 | 20 ++++-----
 ts2panda/tests/regAllocator.test.ts           |  2 +-
 .../statements/functionDeclaration.test.ts    |  8 ++--
 .../statements/variableDeclaration.test.ts    |  2 +-
 ts2panda/tests/strictmode/strictmode.test.ts  |  4 +-
 ts2panda/tests/types/typeUtils.ts             |  2 +-
 ts2panda/tests/utils/base.ts                  |  6 +--
 .../tests/watch_expression/addWatch.test.ts   | 12 +++---
 ts2panda/tools/astPrinter.ts                  |  2 +-
 56 files changed, 278 insertions(+), 278 deletions(-)

diff --git a/ts2panda/src/addVariable2Scope.ts b/ts2panda/src/addVariable2Scope.ts
index 0f64f618bd..f9c7c3935d 100644
--- a/ts2panda/src/addVariable2Scope.ts
+++ b/ts2panda/src/addVariable2Scope.ts
@@ -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 {
diff --git a/ts2panda/src/assemblyDumper.ts b/ts2panda/src/assemblyDumper.ts
index 6b2fc9d793..933d494132 100644
--- a/ts2panda/src/assemblyDumper.ts
+++ b/ts2panda/src/assemblyDumper.ts
@@ -102,25 +102,25 @@ export class AssemblyDumper {
             let formats = node.getFormats();
             var 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;
         }
 
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..b805eea9e4 100644
--- a/ts2panda/src/base/bcGenUtil.ts
+++ b/ts2panda/src/base/bcGenUtil.ts
@@ -178,7 +178,7 @@ export function throwDeleteSuperProperty() {
 }
 
 export function newLexicalEnv(numVars: number, scopeInfoId: string | undefined) {
-    if (scopeInfoId == undefined) {
+    if (scopeInfoId === undefined) {
         return numVars <= MAX_INT8 ? new Newlexenv(new Imm(numVars)) :
                                      new WideNewlexenv(new Imm(numVars));
     }
diff --git a/ts2panda/src/base/iterator.ts b/ts2panda/src/base/iterator.ts
index 1eed765d3f..5ee3cd4ebc 100644
--- a/ts2panda/src/base/iterator.ts
+++ b/ts2panda/src/base/iterator.ts
@@ -55,7 +55,7 @@ export class Iterator {
         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
@@ -99,7 +99,7 @@ export class Iterator {
 
     close() {
         let pg = this.pandaGen;
-        if (this.kind == IteratorType.Normal) {
+        if (this.kind === IteratorType.Normal) {
             pg.closeIterator(this.node, this.iterRecord.iterator);
             return;
         }
diff --git a/ts2panda/src/base/literal.ts b/ts2panda/src/base/literal.ts
index 2cfb246236..fb78fb5105 100644
--- a/ts2panda/src/base/literal.ts
+++ b/ts2panda/src/base/literal.ts
@@ -63,7 +63,7 @@ export class LiteralBuffer {
     }
 
     isEmpty() {
-        return this.lb.length == 0;
+        return this.lb.length === 0;
     }
 
     getLiteral(index: number) {
diff --git a/ts2panda/src/base/lreference.ts b/ts2panda/src/base/lreference.ts
index f51dc6f774..91a44a4213 100644
--- a/ts2panda/src/base/lreference.ts
+++ b/ts2panda/src/base/lreference.ts
@@ -49,11 +49,11 @@ 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.LocalOrGlobal) {
             this.variable = variable!;
-        } else if (refKind == ReferenceKind.MemberAccess) {
+        } else if (refKind === ReferenceKind.MemberAccess) {
             this.obj = compiler.getPandaGen().getTemp();
             this.prop = compiler.getPandaGen().getTemp();
         }
diff --git a/ts2panda/src/base/properties.ts b/ts2panda/src/base/properties.ts
index cd11acf7e4..6775b3f345 100644
--- a/ts2panda/src/base/properties.ts
+++ b/ts2panda/src/base/properties.ts
@@ -59,7 +59,7 @@ export class Property {
     }
 
     getName() {
-        if (typeof (this.name) == 'undefined') {
+        if (typeof (this.name) === 'undefined') {
             throw new Error("this property doesn't have a name");
         }
         return this.name;
@@ -70,7 +70,7 @@ export class Property {
     }
 
     getValue() {
-        if (this.propKind == PropertyKind.Accessor) {
+        if (this.propKind === PropertyKind.Accessor) {
             throw new Error("Accessor doesn't have valueNode")
         }
         return this.valueNode!;
@@ -122,13 +122,13 @@ 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) {
+                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);
                         hasProto = true;
@@ -157,7 +157,7 @@ export function generatePropertyFromExpr(expr: ts.ObjectLiteralExpression): Prop
             }
             case ts.SyntaxKind.MethodDeclaration: {
                 let propName = getPropName(property.name);
-                if (typeof (propName) == 'string' || typeof (propName) == 'number') {
+                if (typeof (propName) === 'string' || typeof (propName) === 'number') {
                     defineProperty(propName, property, PropertyKind.Variable, properties, namedPropertyMap);
                 } else {
                     defineProperty(propName, property, PropertyKind.Computed, properties, namedPropertyMap);
@@ -167,7 +167,7 @@ export function generatePropertyFromExpr(expr: ts.ObjectLiteralExpression): Prop
             case ts.SyntaxKind.GetAccessor:
             case ts.SyntaxKind.SetAccessor: {
                 let propName = getPropName(property.name);
-                if (typeof (propName) == 'string' || typeof (propName) == 'number') {
+                if (typeof (propName) === 'string' || typeof (propName) === 'number') {
                     defineProperty(propName, property, PropertyKind.Accessor, properties, namedPropertyMap);
                 } else {
                     defineProperty(propName, property, PropertyKind.Computed, properties, namedPropertyMap);
@@ -188,7 +188,7 @@ function defineProperty(
     propKind: PropertyKind,
     properties: Property[],
     namedPropertyMap: Map<string, number>) {
-    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);
         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)) {
@@ -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)) {
@@ -245,7 +245,7 @@ export function isConstantExpr(node: ts.Node): boolean {
 }
 
 export function propertyKeyAsString(propName: string | number) {
-    if (typeof (propName) == 'number') {
+    if (typeof (propName) === 'number') {
         return propName.toString();
     }
     return propName;
@@ -258,14 +258,14 @@ export function getPropName(propertyName: ts.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 5c1cc93f53..2dce73b2ca 100644
--- a/ts2panda/src/base/typeSystem.ts
+++ b/ts2panda/src/base/typeSystem.ts
@@ -528,7 +528,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;
         }
 
@@ -593,7 +593,7 @@ export class FunctionType extends BaseType {
                 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;
                 }
             }
diff --git a/ts2panda/src/base/util.ts b/ts2panda/src/base/util.ts
index 24bd25e9a9..951d890366 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;
             }
         });
@@ -102,8 +102,8 @@ export function addUnicodeEscape(text: string) {
     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,7 +115,7 @@ export function addUnicodeEscape(text: string) {
         }
     }
 
-    if (secondIdx == len && firstIdx != secondIdx) {
+    if (secondIdx === len && firstIdx != secondIdx) {
         newText += text.substr(firstIdx);
     }
 
@@ -334,10 +334,10 @@ export function getRecordTypeFlag(recordType: boolean) {
 }
 
 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) {
@@ -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));
     }
@@ -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;
diff --git a/ts2panda/src/cmdOptions.ts b/ts2panda/src/cmdOptions.ts
index ff02ad83b2..81af2422e0 100644
--- a/ts2panda/src/cmdOptions.ts
+++ b/ts2panda/src/cmdOptions.ts
@@ -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;
diff --git a/ts2panda/src/compiler.ts b/ts2panda/src/compiler.ts
index 4818a0fd77..2faf028ae3 100644
--- a/ts2panda/src/compiler.ts
+++ b/ts2panda/src/compiler.ts
@@ -163,7 +163,7 @@ export class Compiler {
         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);
@@ -191,7 +191,7 @@ 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) {
+            if (v.scope === functionScope) {
                 this.pandaGen.loadAccumulator(NodeKind.FirstNodeOfFunction,
                                               getVregisterCache(this.pandaGen, CacheList.FUNC));
                 this.pandaGen.storeAccToLexEnv(NodeKind.FirstNodeOfFunction, v.scope, v.level, v.v, true);
@@ -224,7 +224,7 @@ 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);
     }
@@ -239,7 +239,7 @@ export class Compiler {
 
         statements.forEach((stmt) => {
             this.compileStatement(stmt);
-            if (stmt.kind == ts.SyntaxKind.ReturnStatement) {
+            if (stmt.kind === ts.SyntaxKind.ReturnStatement) {
                 unreachableFlag = true;
             }
         });
@@ -258,11 +258,11 @@ export class Compiler {
     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();
@@ -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);
@@ -486,11 +486,11 @@ export class Compiler {
             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)
+            if ((astutils.getVarDeclarationKind(decl) === VarDeclarationKind.LET)
                 && decl.parent.kind != ts.SyntaxKind.CatchClause) {
                 this.pandaGen.loadAccumulator(decl, getVregisterCache(this.pandaGen, CacheList.undefined));
             }
@@ -593,7 +593,7 @@ export class Compiler {
         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);
@@ -739,7 +739,7 @@ export class Compiler {
 
     compileCondition(expr: ts.Expression, ifFalseLabel: Label) {
         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) {
@@ -935,7 +935,7 @@ export class Compiler {
             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);
@@ -948,7 +948,7 @@ export class Compiler {
     }
 
     private compileBooleanLiteral(lit: ts.BooleanLiteral) {
-        if (lit.kind == ts.SyntaxKind.TrueKeyword) {
+        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));
@@ -956,16 +956,16 @@ export class Compiler {
     }
 
     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))
@@ -1224,9 +1224,9 @@ export class Compiler {
             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;
         }
@@ -1485,7 +1485,7 @@ 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),
diff --git a/ts2panda/src/compilerDriver.ts b/ts2panda/src/compilerDriver.ts
index ca2e9f1f62..c9a8ad3725 100644
--- a/ts2panda/src/compilerDriver.ts
+++ b/ts2panda/src/compilerDriver.ts
@@ -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);
@@ -408,7 +408,7 @@ export class CompilerDriver {
         } else {
             let funcNode = <ts.FunctionLikeDeclaration>node;
             name = (<FunctionScope>recorder.getScopeOfNode(funcNode)).getFuncName();
-            if (name == '') {
+            if (name === '') {
                 if ((ts.isFunctionDeclaration(node) && hasExportKeywordModifier(node) && hasDefaultKeywordModifier(node))
                     || ts.isExportAssignment(findOuterNodeOfParenthesis(node))) {
                     return `${this.getFormatedRecordName()}default`;
@@ -416,7 +416,7 @@ export class CompilerDriver {
                 return `${this.getFormatedRecordName()}#${this.getFuncId(funcNode)}#`;
             }
 
-            if (name == "func_main_0") {
+            if (name === "func_main_0") {
                 return `${this.getFormatedRecordName()}#${this.getFuncId(funcNode)}#${name}`;
             }
 
@@ -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"
diff --git a/ts2panda/src/compilerStatistics.ts b/ts2panda/src/compilerStatistics.ts
index e94a3e1543..ee4b375511 100644
--- a/ts2panda/src/compilerStatistics.ts
+++ b/ts2panda/src/compilerStatistics.ts
@@ -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,7 +120,7 @@ class HistogramStatistics {
     }
 
     getInsName(ins: IRNode): string {
-        if (ins.kind == IRNodeKind.LABEL) {
+        if (ins.kind === IRNodeKind.LABEL) {
             return "Label"
         }
 
diff --git a/ts2panda/src/compilerUtils.ts b/ts2panda/src/compilerUtils.ts
index 1d406d114b..a5fe14a2e7 100644
--- a/ts2panda/src/compilerUtils.ts
+++ b/ts2panda/src/compilerUtils.ts
@@ -138,7 +138,7 @@ function compileArrayDestructuring(arr: ts.ArrayBindingOrAssignmentPattern, pand
             hasInit ? getDefaultLabel : getUndefinedLabel
         );
 
-        // iterdone == false, get current itervalue
+        // iterdone === false, get current itervalue
         iterator.iteratorValue(nextResult);
 
         if (hasInit) {
@@ -218,7 +218,7 @@ 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,
@@ -256,7 +256,7 @@ 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();
@@ -395,7 +395,7 @@ function emitRestProperty(restProperty: ts.BindingElement | ts.SpreadAssignment,
     let target = isDeclaration ? (<ts.BindingElement>restProperty).name : (<ts.SpreadAssignment>restProperty).expression;
     let lRef = LReference.generateLReference(compiler, target, true);
 
-    if (excludedProp.length == 0) {
+    if (excludedProp.length === 0) {
         excludedProp = [getVregisterCache(pandaGen, CacheList.undefined)];
     }
 
diff --git a/ts2panda/src/debuginfo.ts b/ts2panda/src/debuginfo.ts
index 7e95232598..f012fb02a9 100644
--- a/ts2panda/src/debuginfo.ts
+++ b/ts2panda/src/debuginfo.ts
@@ -281,7 +281,7 @@ export class DebugInfo {
 
         // count pos offset
         for (let i = 0; i < insns.length; i++) {
-            if (insns[i].debugPosInfo.getDebugPosInfoNodeState() == NodeKind.FirstNodeOfFunction) {
+            if (insns[i].debugPosInfo.getDebugPosInfoNodeState() === NodeKind.FirstNodeOfFunction) {
                 DebugInfo.setInvalidPosInfoForUninitializeIns(insns[i].debugPosInfo, pandaGen);
             }
 
@@ -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));
diff --git a/ts2panda/src/expression/arrayLiteralExpression.ts b/ts2panda/src/expression/arrayLiteralExpression.ts
index 3ce4a7df27..74e8914b6c 100644
--- a/ts2panda/src/expression/arrayLiteralExpression.ts
+++ b/ts2panda/src/expression/arrayLiteralExpression.ts
@@ -32,7 +32,7 @@ export function compileArrayLiteralExpression(compiler: Compiler, node: ts.Array
 export function createArrayFromElements(node: ts.Node, compiler: Compiler, elements: ts.NodeArray<ts.Expression>, arrayObj: VReg) {
     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);
diff --git a/ts2panda/src/expression/callExpression.ts b/ts2panda/src/expression/callExpression.ts
index a42cb04296..17cbbfe5f0 100644
--- a/ts2panda/src/expression/callExpression.ts
+++ b/ts2panda/src/expression/callExpression.ts
@@ -29,7 +29,7 @@ export function compileCallExpression(expr: ts.CallExpression, compiler: Compile
 
     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(
diff --git a/ts2panda/src/expression/memberAccessExpression.ts b/ts2panda/src/expression/memberAccessExpression.ts
index 1183bb7bef..e96363299e 100644
--- a/ts2panda/src/expression/memberAccessExpression.ts
+++ b/ts2panda/src/expression/memberAccessExpression.ts
@@ -66,7 +66,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 +75,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)) {
diff --git a/ts2panda/src/expression/metaProperty.ts b/ts2panda/src/expression/metaProperty.ts
index f9c7447409..a9ed69b3d0 100644
--- a/ts2panda/src/expression/metaProperty.ts
+++ b/ts2panda/src/expression/metaProperty.ts
@@ -21,7 +21,7 @@ import * as jshelpers from "../jshelpers";
 export function compileMetaProperty(expr: ts.MetaProperty, compiler: Compiler) {
     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/objectLiteralExpression.ts b/ts2panda/src/expression/objectLiteralExpression.ts
index 1d6af9384c..fa0a8f844e 100644
--- a/ts2panda/src/expression/objectLiteralExpression.ts
+++ b/ts2panda/src/expression/objectLiteralExpression.ts
@@ -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);
         }
@@ -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");
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..1da888ebbb 100644
--- a/ts2panda/src/expression/regularExpression.ts
+++ b/ts2panda/src/expression/regularExpression.ts
@@ -38,9 +38,9 @@ export function compileRegularExpressionLiteral(compiler: Compiler, regexp: ts.R
     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);
diff --git a/ts2panda/src/index.ts b/ts2panda/src/index.ts
index 92648846c0..0e63d8793b 100644
--- a/ts2panda/src/index.ts
+++ b/ts2panda/src/index.ts
@@ -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;
                             }
                         }
@@ -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);
@@ -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);
@@ -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;
diff --git a/ts2panda/src/lexenv.ts b/ts2panda/src/lexenv.ts
index 0b9ab61236..bac8393e23 100644
--- a/ts2panda/src/lexenv.ts
+++ b/ts2panda/src/lexenv.ts
@@ -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));
@@ -200,7 +200,7 @@ function checkConstAssignment(pg: PandaGen, v: Variable, expansion: IRNode[], no
         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..92da70742b 100644
--- a/ts2panda/src/lexicalBinder.ts
+++ b/ts2panda/src/lexicalBinder.ts
@@ -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,7 +215,7 @@ export class LexicalBinder {
 
         if ((ts.isVariableDeclaration(parent) || ts.isClassDeclaration(parent) ||
              ts.isClassExpression(parent) || ts.isFunctionLike(parent))
-             && parent.name == id) {
+             && parent.name === id) {
             return true;
         }
 
@@ -224,7 +224,7 @@ export class LexicalBinder {
 
     isPropertyName(id: ts.Identifier) {
         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..52461cc65f 100644
--- a/ts2panda/src/log.ts
+++ b/ts2panda/src/log.ts
@@ -39,7 +39,7 @@ export function printAstRecursively(node: ts.Node, indentLevel: number, sourceFi
     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/pandagen.ts b/ts2panda/src/pandagen.ts
index dd46cd8f7a..703ffb5b6f 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;
diff --git a/ts2panda/src/recorder.ts b/ts2panda/src/recorder.ts
index eea7f7f0fa..da377cafea 100644
--- a/ts2panda/src/recorder.ts
+++ b/ts2panda/src/recorder.ts
@@ -101,7 +101,7 @@ export class Recorder {
 
     private setParent(node: ts.Node) {
         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);
@@ -289,13 +289,13 @@ export class Recorder {
         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 +312,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 +328,7 @@ export class Recorder {
             }
         }
 
-        if (name == MandatoryArguments) {
+        if (name === MandatoryArguments) {
             let varialbeScope = scope.getNearestVariableScope();
             varialbeScope?.setUseArgs(true);
         }
@@ -342,7 +342,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 +361,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 +471,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);
             }
@@ -526,7 +526,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);
                     }
@@ -670,7 +670,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 +679,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 = '';
                         }
                     }
@@ -764,7 +764,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;
                     }
                 }
@@ -800,7 +800,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;
                 }
diff --git a/ts2panda/src/regAllocator.ts b/ts2panda/src/regAllocator.ts
index 790745246c..4d2ee2afef 100644
--- a/ts2panda/src/regAllocator.ts
+++ b/ts2panda/src/regAllocator.ts
@@ -87,11 +87,11 @@ 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) {
+                    } 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.SrcDstVReg) {
                         head.push(new Mov(spill, vOrigin));
                         tail.push(new Mov(vOrigin, spill))
                     } else {
@@ -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;
         }
 
diff --git a/ts2panda/src/scope.ts b/ts2panda/src/scope.ts
index 616d899360..df410a2822 100644
--- a/ts2panda/src/scope.ts
+++ b/ts2panda/src/scope.ts
@@ -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;
             }
 
@@ -261,7 +261,7 @@ export abstract class Scope {
     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];
             }
         }
@@ -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);
@@ -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);
@@ -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 {
@@ -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
diff --git a/ts2panda/src/statement/classStatement.ts b/ts2panda/src/statement/classStatement.ts
index e455b1a3ae..7a85653afb 100644
--- a/ts2panda/src/statement/classStatement.ts
+++ b/ts2panda/src/statement/classStatement.ts
@@ -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++;
@@ -110,7 +110,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;
         }
     }
@@ -442,7 +442,7 @@ export function defineClassMember(
     properties: Property[],
     namedPropertyMap: Map<string, Property>) {
     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 +455,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)) {
@@ -512,7 +512,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)) {
@@ -576,7 +576,7 @@ function generatePropertyFromExpr(node: ts.ClassLikeDeclaration, classFields: Ar
             }
             case ts.SyntaxKind.MethodDeclaration: {
                 let memberName = getPropName(member.name!);
-                if (typeof (memberName) == 'string' || typeof (memberName) == 'number') {
+                if (typeof (memberName) === 'string' || typeof (memberName) === 'number') {
                     if (defineClassMember(memberName, member, PropertyKind.Variable, properties, namedPropertyMap)) {
                         staticNum++;
                     }
@@ -590,7 +590,7 @@ 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 (typeof (accessorName) === 'string' || typeof (accessorName) === 'number') {
                     if (defineClassMember(accessorName, member, PropertyKind.Accessor, properties, namedPropertyMap)) {
                         staticNum++;
                     }
@@ -726,7 +726,7 @@ function scalarArrayEquals(node1: ts.Node | undefined, node2: ts.Node | undefine
         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) {
@@ -754,7 +754,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,7 +785,7 @@ 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;
     }
 
@@ -815,8 +815,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..25bc60c421 100644
--- a/ts2panda/src/statement/forOfStatement.ts
+++ b/ts2panda/src/statement/forOfStatement.ts
@@ -118,7 +118,7 @@ export function getIteratorRecord(pandagen: PandaGen, node: ts.Node, nextMethod:
 }
 
 function getIterator(pandagen: PandaGen, node: ts.Node, type: IteratorType) {
-    if (type == IteratorType.Async) {
+    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..9c684e4afe 100644
--- a/ts2panda/src/statement/labelTarget.ts
+++ b/ts2panda/src/statement/labelTarget.ts
@@ -81,7 +81,7 @@ export class LabelTarget {
     }
 
     private static isLabelTargetsEmpty(): boolean {
-        if (LabelTarget.labelTargetStack.length == 0) {
+        if (LabelTarget.labelTargetStack.length === 0) {
             return true;
         }
         return false;
@@ -120,7 +120,7 @@ export class LabelTarget {
     }
 
     static updateName2LabelTarget(node: ts.Node, labelTarget: LabelTarget) {
-        while (node.kind == ts.SyntaxKind.LabeledStatement) {
+        while (node.kind === ts.SyntaxKind.LabeledStatement) {
             let labeledStmt = <ts.LabeledStatement>node;
             let labelName = jshelpers.getTextOfIdentifierOrLiteral(labeledStmt.label);
 
diff --git a/ts2panda/src/statement/returnStatement.ts b/ts2panda/src/statement/returnStatement.ts
index 6b4365aa7a..ef075b1ecd 100644
--- a/ts2panda/src/statement/returnStatement.ts
+++ b/ts2panda/src/statement/returnStatement.ts
@@ -43,13 +43,13 @@ function compileReturnInDerivedCtor(stmt: ts.ReturnStatement, returnValue: VReg,
     if (!expr) {
         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) {
+        if (expr.kind === ts.SyntaxKind.ThisKeyword) {
             pandaGen.moveVreg(stmt, need2CheckSuper, getVregisterCache(pandaGen, CacheList.True));
         } else {
             compiler.compileExpression(expr);
diff --git a/ts2panda/src/statement/tryStatement.ts b/ts2panda/src/statement/tryStatement.ts
index f20de8ef20..4ebfb345e5 100644
--- a/ts2panda/src/statement/tryStatement.ts
+++ b/ts2panda/src/statement/tryStatement.ts
@@ -328,7 +328,7 @@ export class TryBuilderWithForOf extends TryBuilderBase {
         pandaGen.storeAccumulator(this.stmt, this.iterator.getNextMethod());
         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);
         }
 
@@ -340,7 +340,7 @@ export class TryBuilderWithForOf extends TryBuilderBase {
     }
 
     compileFinalizer(cfc: ControlFlowChange, continueTargetLabel: Label) {
-        if (cfc == ControlFlowChange.Break || continueTargetLabel != this.labelTarget.getContinueTargetLabel()) {
+        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");
@@ -358,7 +358,7 @@ export class TryBuilderWithForOf extends TryBuilderBase {
 
     private compileIteratorNext(stmt: ts.ForOfStatement, pandagen: PandaGen, iterator: IteratorRecord, resultObj: VReg) {
         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);
diff --git a/ts2panda/src/strictMode.ts b/ts2panda/src/strictMode.ts
index a3b0bc1e24..5471984c1e 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;
     }
 
diff --git a/ts2panda/src/syntaxCheckHelper.ts b/ts2panda/src/syntaxCheckHelper.ts
index 38a785e6e9..c32e6e3891 100644
--- a/ts2panda/src/syntaxCheckHelper.ts
+++ b/ts2panda/src/syntaxCheckHelper.ts
@@ -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;
@@ -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;
             }
         }
diff --git a/ts2panda/src/syntaxChecker.ts b/ts2panda/src/syntaxChecker.ts
index 69750aa96d..0842a918f2 100644
--- a/ts2panda/src/syntaxChecker.ts
+++ b/ts2panda/src/syntaxChecker.ts
@@ -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);
         }
@@ -126,7 +126,7 @@ function hasDuplicateExportedFuncDecl(decl: FuncDecl, exportFuncMap: Map<string,
     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]);
         }
     }
@@ -134,7 +134,7 @@ function hasDuplicateExportedFuncDecl(decl: FuncDecl, exportFuncMap: Map<string,
 
 function hasDuplicateEntryAcrossScope(decl1: Decl, decl2: Decl) {
     if ((decl2 instanceof LetDecl) || (decl2 instanceof ConstDecl)) {
-        return decl1.name == decl2.name;
+        return decl1.name === decl2.name;
     }
 }
 
@@ -142,7 +142,7 @@ function hasDuplicateEntryInScope(decl1: Decl, decl2: Decl, scope: Scope) {
     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,7 +167,7 @@ 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;
         }
     }
 
@@ -180,7 +180,7 @@ function checkDuplicateInCatch(blockScope: Scope, catchScope: Scope) {
 
     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,7 +190,7 @@ function checkDuplicateInCatch(blockScope: Scope, catchScope: Scope) {
                 continue;
             }
 
-            if (catchParameters[i].name == bodyDecls[m].name) {
+            if (catchParameters[i].name === bodyDecls[m].name) {
                 throwDupIdError(bodyDecls[m]);
             }
         }
@@ -262,7 +262,7 @@ function checkDeclareGlobalId(decl: Decl, scope: Scope) {
 
 function throwDupIdError(decl: Decl) {
     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]);
@@ -324,13 +324,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;
@@ -876,13 +876,13 @@ function checkClassDeclarationHeritageClauses(node: ts.ClassLikeDeclaration) {
     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);
             }
@@ -903,7 +903,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);
             }
@@ -915,8 +915,8 @@ 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) {
+        || 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);
     }
 }
@@ -1339,7 +1339,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 +1402,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);
                 }
 
diff --git a/ts2panda/src/syntaxCheckerForStrcitMode.ts b/ts2panda/src/syntaxCheckerForStrcitMode.ts
index 5747aadad8..fe7bfee79c 100644
--- a/ts2panda/src/syntaxCheckerForStrcitMode.ts
+++ b/ts2panda/src/syntaxCheckerForStrcitMode.ts
@@ -124,7 +124,7 @@ function checkBinaryExpression(node: ts.BinaryExpression) {
 
 function checkContextualIdentifier(node: ts.Identifier) {
     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']);
     }
 
@@ -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);
                 }
             });
diff --git a/ts2panda/src/ts2panda.ts b/ts2panda/src/ts2panda.ts
index f6d17a09f2..c47b55cbfa 100644
--- a/ts2panda/src/ts2panda.ts
+++ b/ts2panda/src/ts2panda.ts
@@ -147,9 +147,9 @@ export class Ts2Panda {
 
             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,
             ));
@@ -158,7 +158,7 @@ export class Ts2Panda {
         return {
             insns: insns,
             regsNum: (pg.getTotalRegsNum() - pg.getParametersCount()),
-            labels: labels.length == 0 ? undefined : labels
+            labels: labels.length === 0 ? undefined : labels
         };
     }
 
@@ -277,7 +277,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];
@@ -287,7 +287,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) {
@@ -299,7 +299,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();
diff --git a/ts2panda/src/typeChecker.ts b/ts2panda/src/typeChecker.ts
index 85764ad230..eda30023f7 100644
--- a/ts2panda/src/typeChecker.ts
+++ b/ts2panda/src/typeChecker.ts
@@ -113,7 +113,7 @@ export class TypeChecker {
             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;
@@ -165,7 +165,7 @@ export class TypeChecker {
             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;
         }
@@ -241,7 +241,7 @@ export class TypeChecker {
                 return arrayType.shiftedTypeIndex;
             case ts.SyntaxKind.ParenthesizedType:
                 let subType = (<ts.ParenthesizedTypeNode>typeNode).type
-                if (subType.kind == ts.SyntaxKind.UnionType) {
+                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];
@@ -322,11 +322,11 @@ export class TypeChecker {
         }
 
         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) {
@@ -341,7 +341,7 @@ export class TypeChecker {
         }
         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);
@@ -359,7 +359,7 @@ export class TypeChecker {
             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) {
@@ -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;
         }
@@ -400,7 +400,7 @@ export class TypeChecker {
         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..3cb1fd8cae 100644
--- a/ts2panda/src/typeRecorder.ts
+++ b/ts2panda/src/typeRecorder.ts
@@ -210,7 +210,7 @@ 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);
         }
     }
diff --git a/ts2panda/src/variable.ts b/ts2panda/src/variable.ts
index 4f51d0af8b..4235bfe1ab 100644
--- a/ts2panda/src/variable.ts
+++ b/ts2panda/src/variable.ts
@@ -98,27 +98,27 @@ export abstract class Variable {
     }
 
     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;
     }
 }
 
@@ -136,7 +136,7 @@ export class LocalVariable extends Variable {
 
     isInitialized() {
         if (this.status != null) {
-            return this.status == InitStatus.INITIALIZED;
+            return this.status === InitStatus.INITIALIZED;
         }
         return true;
     }
@@ -159,7 +159,7 @@ export class ModuleVariable extends Variable {
 
     isInitialized() {
         if (this.status != null) {
-            return this.status == InitStatus.INITIALIZED;
+            return this.status === InitStatus.INITIALIZED;
         }
         return true;
     }
@@ -193,8 +193,8 @@ export const MandatoryThis = "this";
 export const MandatoryArguments = "arguments";
 
 export function isMandatoryParam(name: string) {
-    if (name == MandatoryFuncObj || name == MandatoryArguments ||
-        name == MandatoryNewTarget || name == MandatoryThis) {
+    if (name === MandatoryFuncObj || name === MandatoryArguments ||
+        name === MandatoryNewTarget || name === MandatoryThis) {
         return true;
     }
 
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/functionExpression.test.ts b/ts2panda/tests/expression/functionExpression.test.ts
index da9270f1ca..a13301db0a 100644
--- a/ts2panda/tests/expression/functionExpression.test.ts
+++ b/ts2panda/tests/expression/functionExpression.test.ts
@@ -71,7 +71,7 @@ describe("compileFunctionExpression", function () {
 
         let checkCount = 0;
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "UnitTest.test") {
+            if (pg.internalName === "UnitTest.test") {
                 expect(checkInstructions(pg.getInsns(), expected_func), "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) {
@@ -183,12 +183,12 @@ describe("compileFunctionExpression", function () {
         ];
 
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "UnitTest.p") {
+            if (pg.internalName === "UnitTest.p") {
                 expect(checkInstructions(pg.getInsns(), expected_func), "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) {
@@ -289,12 +289,12 @@ describe("compileFunctionExpression", function () {
         let checkCount = 0;
 
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "UnitTest.a") {
+            if (pg.internalName === "UnitTest.a") {
                 expect(checkInstructions(pg.getInsns(), expected_func), "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');
@@ -350,7 +350,7 @@ 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());
                 })
@@ -358,7 +358,7 @@ describe("compileFunctionExpression", function () {
                 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/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/lexenv.test.ts b/ts2panda/tests/lexenv.test.ts
index ac103f52d5..418136e2d9 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]);
@@ -372,9 +372,9 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
         ];
 
         pandaGens.forEach((pg) => {
-            if (pg.internalName == "UnitTest.func_main_0") {
+            if (pg.internalName === "UnitTest.func_main_0") {
                 expect(checkInstructions(pg.getInsns(), expected_main)).to.be.true;
-            } else if (pg.internalName == "UnitTest.func") {
+            } else if (pg.internalName === "UnitTest.func") {
                 expect(checkInstructions(pg.getInsns(), expected_func)).to.be.true;
             }
         })
@@ -410,11 +410,11 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
 
         pandaGens.forEach((pg) => {
             let scope = <VariableScope>pg.getScope();
-            if (pg.internalName == "UnitTest.func_main_0") {
+            if (pg.internalName === "UnitTest.func_main_0") {
                 expect(checkInstructions(pg.getInsns(), expected_main), "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(scope.getNumLexEnv(), "func scope has 1 lexvar").to.be.equal(0);
diff --git a/ts2panda/tests/regAllocator.test.ts b/ts2panda/tests/regAllocator.test.ts
index 185ebd3594..9f62788fb8 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;
             }
         }
diff --git a/ts2panda/tests/statements/functionDeclaration.test.ts b/ts2panda/tests/statements/functionDeclaration.test.ts
index 6405c9cd96..5eacce8a08 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 () {
@@ -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") {
+            } else if (element.internalName === "UnitTest.test") {
                 let insns = element.getInsns();
                 expect(checkInstructions(insns, expected_func)).to.be.true;
                 let parameterLength = element.getParameterLength();
-                expect(parameterLength == 1).to.be.true;
+                expect(parameterLength === 1).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/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/typeUtils.ts b/ts2panda/tests/types/typeUtils.ts
index 88fafdb376..5e39e2e6d4 100644
--- a/ts2panda/tests/types/typeUtils.ts
+++ b/ts2panda/tests/types/typeUtils.ts
@@ -73,7 +73,7 @@ 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()
diff --git a/ts2panda/tests/utils/base.ts b/ts2panda/tests/utils/base.ts
index 82def16907..58ad14bbe2 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";
@@ -178,7 +178,7 @@ 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");
         })
     }
 
@@ -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/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..ae1058f1af 100644
--- a/ts2panda/tools/astPrinter.ts
+++ b/ts2panda/tools/astPrinter.ts
@@ -77,7 +77,7 @@ 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 {
-- 
Gitee